From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a02557.html | 7530 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 7530 insertions(+) create mode 100644 docs/doxygen/nel/a02557.html (limited to 'docs/doxygen/nel/a02557.html') diff --git a/docs/doxygen/nel/a02557.html b/docs/doxygen/nel/a02557.html new file mode 100644 index 00000000..c18f4696 --- /dev/null +++ b/docs/doxygen/nel/a02557.html @@ -0,0 +1,7530 @@ + + +NeL: NLGEORGES::CFormElmVirtualStruct class Reference + + + +
+

NLGEORGES::CFormElmVirtualStruct Class Reference

#include <form_elm.h> +

+

Inheritance diagram for NLGEORGES::CFormElmVirtualStruct: +

+ +NLGEORGES::CFormElmStruct +NLGEORGES::CFormElm +NLGEORGES::UFormElm + +

Detailed Description

+Define an array of elements +

+ +

+Definition at line 327 of file form_elm.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

enum  TEval { NoEval, +Formula, +Eval + }
 Value evalution. More...

enum  TWhereIsNode { NodeForm, +NodeParentForm, +NodeDfn, +NodeType + }
 Where a node has been found. More...

enum  TWhereIsValue {
+  ValueForm, +ValueParentForm, +ValueDefaultDfn, +ValueDefaultType, +
+  Dummy = 0xffffffff +
+ }
 Where a value has been found. More...


Public Member Functions

bool arrayDeleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, bool verbose, uint arrayIndex) const
bool arrayInsertNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, bool verbose, uint arrayIndex) const
void build (const CFormDfn *dfn)
 CFormElmVirtualStruct (CForm *form, CFormElm *parentNode, const CFormDfn *parentDfn, uint parentIndex)
void clean ()
 Reset contents.

bool convertValue (NLMISC::CRGBA &result, const char *value) const
bool convertValue (bool &result, const char *value) const
bool convertValue (double &result, const char *value) const
bool convertValue (float &result, const char *value) const
bool convertValue (uint32 &result, const char *value) const
bool convertValue (sint32 &result, const char *value) const
bool convertValue (uint16 &result, const char *value) const
bool convertValue (sint16 &result, const char *value) const
bool convertValue (uint8 &result, const char *value) const
bool convertValue (sint8 &result, const char *value) const
bool createNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, bool &created)
bool deleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array)
virtual bool getArrayNode (UFormElm **result, uint arrayIndex)
virtual bool getArrayNode (const UFormElm **result, uint arrayIndex) const
virtual bool getArrayNodeName (std::string &result, uint arrayIndex) const
 Return the name of a table element.

virtual bool getArraySize (uint &size) const
 Return true if the element is an array and fill size with the array size.

virtual bool getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
 Warning, only R, G and B members are filled, not A.

virtual bool getArrayValue (bool &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (double &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (float &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (uint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (sint32 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (uint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (sint16 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (uint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (sint8 &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
virtual bool getArrayValue (std::string &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const
void getDependencies (std::set< std::string > &dependencies) const
bool getDfnName (std::string &dfnName) const
 Get the dfn filename for this virtual struct. Must be a virtual struct node.

CFormgetForm () const
void getFormName (std::string &result, const CFormElm *child) const
bool getNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const
virtual bool getNodeByName (UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0)
virtual bool getNodeByName (const UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0) const
virtual UFormElmgetParent () const
UFormDfngetStructDfn ()
 Return the struct dfn.

bool getStructNode (uint element, UFormElm **result)
 Return a mutable element pointer. Can be NULL if the node doesn't exist.

bool getStructNode (uint element, const UFormElm **result) const
 Return a const element pointer. Can be NULL if the node doesn't exist.

bool getStructNodeName (uint element, std::string &result) const
 Return the element name.

bool getStructSize (uint &size) const
 Return the struct size.

virtual bool getValue (NLMISC::CRGBA &resultname, TEval evaluate) const
 Warning, only R, G and B members are filled, not A.

virtual bool getValue (bool &resultname, TEval evaluate) const
virtual bool getValue (double &resultname, TEval evaluate) const
virtual bool getValue (float &resultname, TEval evaluate) const
virtual bool getValue (uint32 &resultname, TEval evaluate) const
virtual bool getValue (sint32 &resultname, TEval evaluate) const
virtual bool getValue (uint16 &resultname, TEval evaluate) const
virtual bool getValue (sint16 &resultname, TEval evaluate) const
virtual bool getValue (uint8 &resultname, TEval evaluate) const
virtual bool getValue (sint8 &resultname, TEval evaluate) const
virtual bool getValue (std::string &resultname, TEval evaluate) const
virtual bool getValueByName (NLMISC::CRGBA &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
 Warning, only R, G and B members are filled, not A.

virtual bool getValueByName (bool &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (double &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (float &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (uint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (sint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (uint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (sint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (uint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (sint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool getValueByName (std::string &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const
virtual bool isArray () const
 Return true if the element is an array.

virtual bool isAtom () const
 Return true if the element is an atom.

bool isStruct () const
 Return true if the element is a struct or a virtual struct.

bool isUsed (const CForm *form) const
bool isVirtualStruct () const
 Return true if the element is a virtual struct.

void read (xmlNodePtr node, CFormLoader &loader, const CFormDfn *dfn, CForm *form)
void read (xmlNodePtr node, CFormLoader &loader, CForm *form)
virtual bool setValueByName (NLMISC::CRGBA value, const char *name, bool *created)
virtual bool setValueByName (bool value, const char *name, bool *created)
virtual bool setValueByName (double value, const char *name, bool *created)
virtual bool setValueByName (float value, const char *name, bool *created)
virtual bool setValueByName (uint32 value, const char *name, bool *created)
virtual bool setValueByName (sint32 value, const char *name, bool *created)
virtual bool setValueByName (uint16 value, const char *name, bool *created)
virtual bool setValueByName (sint16 value, const char *name, bool *created)
virtual bool setValueByName (uint8 value, const char *name, bool *created)
virtual bool setValueByName (sint8 value, const char *name, bool *created)
virtual bool setValueByName (const char *value, const char *name, bool *created)
void unlink (CFormElm *child)
virtual void warning (bool exception, const char *function, const char *format,...) const
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite=false) const
virtual ~CFormElmVirtualStruct ()

Static Public Member Functions

const char * tokenize (const char *name, std::string &str, uint &errorIndex, uint &code)

Data Fields

std::string DfnFilename
std::vector< CFormElmStructElm > Elements
NLMISC::CSmartPtr< CFormDfnFormDfn

Protected Types

enum  TNodeAction { Return, +Create, +Delete + }

Static Protected Member Functions

bool getIternalNodeByName (CForm *form, const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round)
void warning (bool exception, const char *formName, const char *formFileName, const char *function, const char *format,...)

Protected Attributes

CFormForm
const CFormDfnParentDfn
uint ParentIndex
CFormElmParentNode
uint32 Round
+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NLGEORGES::UFormElm::TEval [inherited] +
+
+ + + + + +
+   + + +

+Value evalution. +

+

Enumeration values:
+ + + + +
NoEval  +
Formula  +The value will not be evaluated at all, the litteral value will be returned.
Eval  +Eval the enumeration value, but don't evaluate the formula nor the value references.
+
+ +

+Definition at line 47 of file u_form_elm.h. +

+

00048         {               
+00049                 NoEval,                         
+00050                 Formula,                        
+00051                 Eval,                           
+00052         };
+
+

+ + + + +
+ + +
enum NLGEORGES::CFormElm::TNodeAction [protected, inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + +
Return  +
Create  +
Delete  +
+
+ +

+Definition at line 195 of file form_elm.h. +

+

00196         {
+00197                 Return,
+00198                 Create,
+00199                 Delete,
+00200         };
+
+

+ + + + +
+ + +
enum NLGEORGES::UFormElm::TWhereIsNode [inherited] +
+
+ + + + + +
+   + + +

+Where a node has been found. +

+

Enumeration values:
+ + + + + +
NodeForm  +
NodeParentForm  +The node has been found in the form.
NodeDfn  +The node has been found in the parent form.
NodeType  +The node is a DFN.
+
+ +

+Definition at line 55 of file u_form_elm.h. +

+

00056         {
+00057                 NodeForm,                       
+00058                 NodeParentForm,         
+00059                 NodeDfn,                        
+00060                 NodeType,                       
+00061         };
+
+

+ + + + +
+ + +
enum NLGEORGES::UFormElm::TWhereIsValue [inherited] +
+
+ + + + + +
+   + + +

+Where a value has been found. +

+

Enumeration values:
+ + + + + + +
ValueForm  +
ValueParentForm  +The value has been found in the form.
ValueDefaultDfn  +The value has been found in the parent form.
ValueDefaultType  +The value has been found in the DFN default value.
Dummy  +The value has been found in the TYPE default value.
+
+ +

+Definition at line 94 of file u_form_elm.h. +

+

00095         {
+00096                 ValueForm,                              
+00097                 ValueParentForm,                
+00098                 ValueDefaultDfn,                
+00099                 ValueDefaultType,               
+00100                 Dummy = 0xffffffff              
+00101         };
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NLGEORGES::CFormElmVirtualStruct::CFormElmVirtualStruct CForm form,
CFormElm parentNode,
const CFormDfn parentDfn,
uint  parentIndex
+
+ + + + + +
+   + + +

+ +

+Definition at line 2134 of file form_elm.cpp. +

+References uint. +

+

02134                                                                                                                             : CFormElmStruct (form, parentNode, parentDfn, parentIndex)
+02135 {
+02136 }
+
+

+ + + + +
+ + + + + + + + + +
virtual NLGEORGES::CFormElmVirtualStruct::~CFormElmVirtualStruct  )  [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 332 of file form_elm.h. +

+

00332 { }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::arrayDeleteNodeByName const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array,
bool  verbose,
uint  arrayIndex
const [inherited]
+
+ + + + + +
+   + + +

+Delete an array node by name The index asked must be < the size of the array. +

+Definition at line 719 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Create, NLGEORGES::CFormElmArray::Elements, NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElm::isArray(), nlassert, NLGEORGES_FIRST_ROUND, NLGEORGES::CFormElm::ParentDfn, NLGEORGES::CFormElm::ParentIndex, type, and uint. +

+

00723 {
+00724         // Get the node by name
+00725         *parentDfn = ParentDfn;
+00726         indexDfn = ParentIndex;
+00727         *nodeDfn = NULL;
+00728         *nodeType = NULL;
+00729         *node = (CFormElm*)this;
+00730         bool created;
+00731         bool parentVDfnArray;
+00732         if (getIternalNodeByName (Form, name, parentDfn, indexDfn, nodeDfn, nodeType, node, type, array, Create, created, parentVDfnArray, verbose, NLGEORGES_FIRST_ROUND))
+00733         {
+00734                 // Must be in the same form
+00735                 nlassert ((*node) && ((*node)->Form == Form));
+00736 
+00737                 // Get its parent
+00738                 CFormElm *parentNode = (*node)->ParentNode;
+00739                 if (parentNode->isArray ())
+00740                 {
+00741                         // Cast pointer
+00742                         CFormElmArray *array = safe_cast<CFormElmArray*>(parentNode);
+00743 
+00744                         // Valid index ?
+00745                         if (arrayIndex<array->Elements.size ())
+00746                         {
+00747                                 // Insert the element
+00748                                 if (array->Elements[arrayIndex].Element)
+00749                                         delete array->Elements[arrayIndex].Element;
+00750 
+00751                                 // Erase the entry
+00752                                 array->Elements.erase (array->Elements.begin () + arrayIndex);
+00753 
+00754                                 // Ok 
+00755                                 return true;
+00756                         }
+00757                 }
+00758         }
+00759         return false;
+00760 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::arrayInsertNodeByName const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array,
bool  verbose,
uint  arrayIndex
const [inherited]
+
+ + + + + +
+   + + +

+Insert an array node by name The index asked must be < the size of the array. +

+Definition at line 645 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::build(), NLGEORGES::CFormElm::Create, NLGEORGES::CFormElmArray::Elements, NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElm::isArray(), nlassert, NLGEORGES_FIRST_ROUND, nlstop, NLGEORGES::CFormElm::ParentDfn, NLGEORGES::CFormElm::ParentIndex, type, and uint. +

+

00649 {
+00650         // Get the node by name
+00651         *parentDfn = ParentDfn;
+00652         indexDfn = ParentIndex;
+00653         *nodeDfn = NULL;
+00654         *nodeType = NULL;
+00655         *node = (CFormElm*)this;
+00656         bool created;
+00657         bool parentVDfnArray;
+00658         if (getIternalNodeByName (Form, name, parentDfn, indexDfn, nodeDfn, nodeType, node, type, array, Create, created, parentVDfnArray, verbose, NLGEORGES_FIRST_ROUND))
+00659         {
+00660                 // Must be in the same form
+00661                 nlassert ((*node) && ((*node)->Form == Form));
+00662 
+00663                 // Get its parent
+00664                 CFormElm *parentNode = (*node)->ParentNode;
+00665                 if (parentNode->isArray ())
+00666                 {
+00667                         // Cast pointer
+00668                         CFormElmArray *array = safe_cast<CFormElmArray*>(parentNode);
+00669 
+00670                         // Valid index ?
+00671                         if (arrayIndex<array->Elements.size ())
+00672                         {
+00673                                 // Insert the element
+00674                                 array->Elements.insert (array->Elements.begin() + arrayIndex);
+00675 
+00676                                 // Create a new element
+00677 
+00678                                 // The new element
+00679                                 CFormElm *newelm = NULL;
+00680                                 switch (type)
+00681                                 {
+00682                                 case UFormDfn::EntryType:
+00683                                         {
+00684                                                 // Create an atom
+00685                                                 CFormElmAtom *atom = new CFormElmAtom (Form, array, *parentDfn, indexDfn);
+00686                                                 newelm = atom;
+00687                                         }
+00688                                         break;
+00689                                 case UFormDfn::EntryDfn:
+00690                                         {
+00691                                                 CFormElmStruct *_struct = new CFormElmStruct (Form, array, *parentDfn, indexDfn);
+00692                                                 _struct->build (*nodeDfn);
+00693                                                 newelm = _struct;
+00694                                         }
+00695                                         break;
+00696                                 case UFormDfn::EntryVirtualDfn:
+00697                                         // todo array of virtual struct
+00698                                         //newelm = new CFormElmVirtualStruct (Form, array, *parentDfn, indexDfn);
+00699                                         break;
+00700                                 default:
+00701                                         nlstop;
+00702                                 }
+00703 
+00704                                 nlassert (newelm);
+00705 
+00706                                 // Set the element pointer
+00707                                 array->Elements[arrayIndex].Element = newelm;
+00708 
+00709                                 // Ok 
+00710                                 return true;
+00711                         }
+00712                 }
+00713         }
+00714         return false;
+00715 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLGEORGES::CFormElmStruct::build const CFormDfn dfn  )  [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 2002 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::clean(), NLGEORGES::CFormDfn::countParentDfn(), NLGEORGES::CFormElmStruct::FormDfn, NLGEORGES::CFormDfn::getParentDfn(), and uint. +

+Referenced by NLGEORGES::CFormElm::arrayInsertNodeByName(), NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElmStruct::read(), and NLGEORGES::CForm::read(). +

+

02003 {
+02004         // Clean the form
+02005         clean ();
+02006 
+02007         // Set the DFN
+02008         FormDfn = (CFormDfn*)dfn;
+02009         
+02010         // Get the parents
+02011         vector<const CFormDfn*> arrayDfn;
+02012         arrayDfn.reserve (dfn->countParentDfn ());
+02013         dfn->getParentDfn (arrayDfn);
+02014 
+02015         // Count element
+02016         uint elementCount = 0;
+02017         uint dfnIndex;
+02018         for (dfnIndex=0; dfnIndex<arrayDfn.size(); dfnIndex++)
+02019         {
+02020                 elementCount += arrayDfn[dfnIndex]->getNumEntry();
+02021         }
+02022 
+02023         // Resize the element array
+02024         Elements.resize (elementCount);
+02025 
+02026         elementCount = 0;
+02027         for (dfnIndex=0; dfnIndex<arrayDfn.size(); dfnIndex++)
+02028         {
+02029                 // For each element
+02030                 for (uint elm=0; elm<arrayDfn[dfnIndex]->Entries.size(); elm++)
+02031                 {
+02032                         // Copy the name
+02033                         Elements[elementCount].Name = arrayDfn[dfnIndex]->Entries[elm].Name;
+02034                         elementCount++;
+02035                 }
+02036         }
+02037 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLGEORGES::CFormElmStruct::clean void   )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Reset contents. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1701 of file form_elm.cpp. +

+References uint. +

+Referenced by NLGEORGES::CFormElmStruct::build(). +

+

01702 {
+01703         // For each element of the array
+01704         uint elm;
+01705         for (elm =0; elm<Elements.size(); elm++)
+01706         {
+01707                 if (Elements[elm].Element)
+01708                         delete Elements[elm].Element;
+01709                 Elements[elm].Element = NULL;
+01710         }
+01711 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue NLMISC::CRGBA result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 657 of file form_elm.h. +

+References NLMISC::CRGBA::B, NLMISC::clamp(), NLMISC::CRGBA::G, NLMISC::CRGBA::R, r, uint8, value, and NLGEORGES::CFormElm::warning(). +

+

00658 {
+00659         float r, g, b;
+00660         if (sscanf (value, "%f,%f,%f", &r, &g, &b) == 3)
+00661         {
+00662                 NLMISC::clamp (r, 0.f, 255.f);
+00663                 NLMISC::clamp (g, 0.f, 255.f);
+00664                 NLMISC::clamp (b, 0.f, 255.f);
+00665                 result.R = (uint8)r;
+00666                 result.G = (uint8)g;
+00667                 result.B = (uint8)b;
+00668                 return true;
+00669         }
+00670 
+00671         // Error message
+00672         warning (false, "convertValue", "Can't convert the string \"%s\" in RGB color.", value);
+00673         
+00674         return false;
+00675 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue bool &  result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 625 of file form_elm.h. +

+References NLMISC::strlwr(), value, and NLGEORGES::CFormElm::warning(). +

+

00626 {
+00627         int tmp;
+00628         if (sscanf (value, "%d", &tmp) == 1)
+00629         {
+00630                 result = tmp != 0;
+00631                 return true;
+00632         }
+00633         else
+00634         {
+00635                 std::string temp = value;
+00636                 temp = NLMISC::strlwr (temp);
+00637                 if (strcmp (temp.c_str (), "true") == 0)
+00638                 {
+00639                         result  = true;
+00640                         return true;
+00641                 }
+00642                 if (strcmp (temp.c_str (), "false") == 0)
+00643                 {
+00644                         result  = false;
+00645                         return true;
+00646                 }
+00647         }
+00648 
+00649         // Error message
+00650         warning (false, "convertValue", "Can't convert the string \"%s\" in boolean.", value);
+00651         
+00652         return false;
+00653 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue double &  result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 607 of file form_elm.h. +

+References value, and NLGEORGES::CFormElm::warning(). +

+

00608 {
+00609         float tmp;
+00610         if (sscanf (value, "%f", &tmp) == 1)
+00611         {
+00612                 result = tmp;
+00613                 return true;
+00614         }
+00615         else
+00616         {
+00617                 // Error message
+00618                 warning (false, "convertValue", "Can't convert the string \"%s\" in double.", value);
+00619         }
+00620         return false;
+00621 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue float &  result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 591 of file form_elm.h. +

+References value, and NLGEORGES::CFormElm::warning(). +

+

00592 {
+00593         if (sscanf (value, "%f", &result) == 1)
+00594         {
+00595                 return true;
+00596         }
+00597         else
+00598         {
+00599                 // Error message
+00600                 warning (false, "convertValue", "Can't convert the string \"%s\" in float.", value);
+00601         }
+00602         return false;
+00603 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue uint32 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 572 of file form_elm.h. +

+References NLMISC::clamp(), sint32, uint32, value, and NLGEORGES::CFormElm::warning(). +

+

00573 {
+00574         float tmp;
+00575         if (sscanf (value, "%f", &tmp) == 1)
+00576         {
+00577                 NLMISC::clamp (tmp, 0.f, 4294967295.f);
+00578                 result = (sint32)tmp;
+00579                 return true;
+00580         }
+00581         else
+00582         {
+00583                 // Error message
+00584                 warning (false, "convertValue", "Can't convert the string \"%s\" in uint32.", value);
+00585         }
+00586         return false;
+00587 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue sint32 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 553 of file form_elm.h. +

+References NLMISC::clamp(), sint32, value, and NLGEORGES::CFormElm::warning(). +

+

00554 {
+00555         float tmp;
+00556         if (sscanf (value, "%f", &tmp) == 1)
+00557         {
+00558                 NLMISC::clamp (tmp, -2147483648.f, 2147483647.f);
+00559                 result = (sint32)tmp;
+00560                 return true;
+00561         }
+00562         else
+00563         {
+00564                 // Error message
+00565                 warning (false, "convertValue", "Can't convert the string \"%s\" in sint32.", value);
+00566         }
+00567         return false;
+00568 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue uint16 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 534 of file form_elm.h. +

+References NLMISC::clamp(), uint16, value, and NLGEORGES::CFormElm::warning(). +

+

00535 {
+00536         float tmp;
+00537         if (sscanf (value, "%f", &tmp) == 1)
+00538         {
+00539                 NLMISC::clamp (tmp, 0.f, 65535.f);
+00540                 result = (uint16)tmp;
+00541                 return true;
+00542         }
+00543         else
+00544         {
+00545                 // Error message
+00546                 warning (false, "convertValue", "Can't convert the string \"%s\" in uint16.", value);
+00547         }
+00548         return false;
+00549 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue sint16 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 515 of file form_elm.h. +

+References NLMISC::clamp(), sint16, value, and NLGEORGES::CFormElm::warning(). +

+

00516 {
+00517         float tmp;
+00518         if (sscanf (value, "%f", &tmp) == 1)
+00519         {
+00520                 NLMISC::clamp (tmp, -32768.f, 32767.f);
+00521                 result = (sint16)tmp;
+00522                 return true;
+00523         }
+00524         else
+00525         {
+00526                 // Error message
+00527                 warning (false, "convertValue", "Can't convert the string \"%s\" in sint16.", value);
+00528         }
+00529         return false;
+00530 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue uint8 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 496 of file form_elm.h. +

+References NLMISC::clamp(), uint8, value, and NLGEORGES::CFormElm::warning(). +

+

00497 {
+00498         float tmp;
+00499         if (sscanf (value, "%f", &tmp) == 1)
+00500         {
+00501                 NLMISC::clamp (tmp, 0.f, 255.f);
+00502                 result = (uint8)tmp;
+00503                 return true;
+00504         }
+00505         else
+00506         {
+00507                 // Error message
+00508                 warning (false, "convertValue", "Can't convert the string \"%s\" in uint8.", value);
+00509         }
+00510         return false;
+00511 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::convertValue sint8 result,
const char *  value
const [inline, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 477 of file form_elm.h. +

+References NLMISC::clamp(), sint8, value, and NLGEORGES::CFormElm::warning(). +

+Referenced by NLGEORGES::CFormElmArray::getArrayValue(), NLGEORGES::CFormElmAtom::getValue(), and NLGEORGES::CFormElm::getValueByName(). +

+

00478 {
+00479         float tmp;
+00480         if (sscanf (value, "%f", &tmp) == 1)
+00481         {
+00482                 NLMISC::clamp (tmp, -128.f, 127.f);
+00483                 result = (sint8)tmp;
+00484                 return true;
+00485         }
+00486         else
+00487         {
+00488                 // Error message
+00489                 warning (false, "convertValue", "Can't convert the string \"%s\" in sint8.", value);
+00490         }
+00491         return false;
+00492 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::createNodeByName const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array,
bool &  created
[inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 596 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Create, NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES_FIRST_ROUND, NLGEORGES::CFormElm::ParentDfn, NLGEORGES::CFormElm::ParentIndex, type, and uint. +

+Referenced by NLGEORGES::CFormElm::setValueByName(). +

+

00600 {
+00601         *parentDfn = ParentDfn;
+00602         indexDfn = ParentIndex;
+00603         *nodeDfn = NULL;
+00604         *nodeType = NULL;
+00605         *node = this;
+00606         bool parentVDfnArray;
+00607         return getIternalNodeByName (Form, name, parentDfn, indexDfn, nodeDfn, nodeType, node, type, array, Create, created, parentVDfnArray, true, NLGEORGES_FIRST_ROUND);
+00608 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::deleteNodeByName const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array
[inherited]
+
+ + + + + +
+   + + +

+Delete a node by name. If the node already exist, return it Delete its parent if not used +

+Definition at line 612 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Delete, NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES_FIRST_ROUND, NLGEORGES::CFormElm::ParentDfn, NLGEORGES::CFormElm::ParentIndex, type, and uint. +

+

00616 {
+00617         *parentDfn = ParentDfn;
+00618         indexDfn = ParentIndex;
+00619         *nodeDfn = NULL;
+00620         *nodeType = NULL;
+00621         *node = this;
+00622         bool created;
+00623         bool parentVDfnArray;
+00624         return getIternalNodeByName (Form, name, parentDfn, indexDfn, nodeDfn, nodeType, node, type, array, Delete, created, parentVDfnArray, true, NLGEORGES_FIRST_ROUND);
+00625 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayNode UFormElm **  result,
uint  arrayIndex
[virtual, inherited]
+
+ + + + + +
+   + + +

+Get a array sub element mutable pointer. If return true, fill result with the arrayIndex cell's element pointer. Can be NULL if the node doesn't exist. +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 76 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00077 { 
+00078         warning (false, "getArrayNode", "This node is not an array.");
+00079         return false; 
+00080 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayNode const UFormElm **  result,
uint  arrayIndex
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Get a array sub element const pointer. If return true, fill result with the arrayIndex cell's element Can be NULL if the node doesn't exist. +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 68 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00069 { 
+00070         warning (false, "getArrayNode", "This node is not an array.");
+00071         return false; 
+00072 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayNodeName std::string &  result,
uint  arrayIndex
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return the name of a table element. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 84 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00085 {
+00086         warning (false, "getArrayNodeName", "This node is not an array.");
+00087         return false;
+00088 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLGEORGES::CFormElm::getArraySize uint size  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the element is an array and fill size with the array size. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 60 of file form_elm.cpp. +

+References size, uint, and NLGEORGES::CFormElm::warning(). +

+

00061 {
+00062         warning (false, "getArraySize", "This node is not an array.");
+00063         return false; 
+00064 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue NLMISC::CRGBA result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Warning, only R, G and B members are filled, not A. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 172 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00173 {
+00174         warning (false, "getArrayValue", "This node is not an array.");
+00175         return false;
+00176 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue bool &  result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 164 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00165 {
+00166         warning (false, "getArrayValue", "This node is not an array.");
+00167         return false;
+00168 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue double &  result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 156 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00157 {
+00158         warning (false, "getArrayValue", "This node is not an array.");
+00159         return false;
+00160 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue float &  result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 148 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00149 {
+00150         warning (false, "getArrayValue", "This node is not an array.");
+00151         return false;
+00152 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue uint32 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 140 of file form_elm.cpp. +

+References uint, uint32, and NLGEORGES::CFormElm::warning(). +

+

00141 {
+00142         warning (false, "getArrayValue", "This node is not an array.");
+00143         return false;
+00144 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue sint32 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 132 of file form_elm.cpp. +

+References sint32, uint, and NLGEORGES::CFormElm::warning(). +

+

00133 {
+00134         warning (false, "getArrayValue", "This node is not an array.");
+00135         return false;
+00136 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue uint16 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 124 of file form_elm.cpp. +

+References uint, uint16, and NLGEORGES::CFormElm::warning(). +

+

00125 {
+00126         warning (false, "getArrayValue", "This node is not an array.");
+00127         return false;
+00128 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue sint16 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 116 of file form_elm.cpp. +

+References sint16, uint, and NLGEORGES::CFormElm::warning(). +

+

00117 {
+00118         warning (false, "getArrayValue", "This node is not an array.");
+00119         return false;
+00120 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue uint8 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 108 of file form_elm.cpp. +

+References uint, uint8, and NLGEORGES::CFormElm::warning(). +

+

00109 {
+00110         warning (false, "getArrayValue", "This node is not an array.");
+00111         return false;
+00112 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue sint8 result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 100 of file form_elm.cpp. +

+References sint8, uint, and NLGEORGES::CFormElm::warning(). +

+

00101 {
+00102         warning (false, "getArrayValue", "This node is not an array.");
+00103         return false;
+00104 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getArrayValue std::string &  result,
uint  arrayIndex,
TEval  evaluate,
TWhereIsValue where
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Get an array value. The node must be an array of atom element.

+

Parameters:
+ + + + + +
result is a reference on the value to fill with the result.
arrayIndex is the array index to evaluate.
evaluate must be true if you want to have an evaluated value, false if you want the formula value.
where is a pointer on the information flag of the value. If Where is not NULL, it is filled with the position where the value has been found.
+
+
Returns:
true if the result has been filled, false if the value has not been found or the cast has failed or the evaluation has failed.
+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 92 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElm::warning(). +

+

00093 {
+00094         warning (false, "getArrayNode", "This node is not an array.");
+00095         return false;
+00096 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLGEORGES::CFormElmStruct::getDependencies std::set< std::string > &  dependencies  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::CFormElm. +

+Definition at line 2116 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::FormDfn, and uint. +

+Referenced by NLGEORGES::CForm::getDependencies(). +

+

02117 {
+02118         // Visit the dfn
+02119         if (FormDfn)
+02120                 FormDfn->getDependencies (dependencies);
+02121 
+02122         // Visit elements
+02123         for (uint i=0; i<Elements.size (); i++)
+02124         {
+02125                 if (Elements[i].Element)
+02126                         Elements[i].Element->getDependencies (dependencies);
+02127         }
+02128 }
+
+

+ + + + +
+ + + + + + + + + + +
bool NLGEORGES::CFormElmVirtualStruct::getDfnName std::string &  dfnName  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the dfn filename for this virtual struct. Must be a virtual struct node. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 2215 of file form_elm.cpp. +

+References DfnFilename. +

+

02216 {
+02217         dfnName = DfnFilename;
+02218         return true;
+02219 }
+
+

+ + + + +
+ + + + + + + + + +
CForm * NLGEORGES::CFormElm::getForm  )  const [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 353 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Form. +

+Referenced by NLGEORGES::CFormElm::warning(). +

+

00354 {
+00355         return Form;
+00356 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NLGEORGES::CFormElmStruct::getFormName std::string &  result,
const CFormElm child
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::CFormElm. +

+Definition at line 2059 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::getFormName(), uint, and NLGEORGES::CFormElmStruct::warning(). +

+Referenced by NLGEORGES::CFormElm::getIternalNodeByName(), warning(), and NLGEORGES::CFormElmStruct::warning(). +

+

02060 {
+02061         // Reset the result
+02062         if (child == NULL)
+02063         {
+02064                 result = "";
+02065                 result.reserve (50);
+02066         }
+02067 
+02068         // Get parent form name
+02069         if (ParentNode)
+02070                 ParentNode->getFormName (result, this);
+02071 
+02072         // Get node name
+02073         if (child)
+02074         {
+02075                 // Look for the child
+02076                 uint i;
+02077                 for (i=0; i<Elements.size (); i++)
+02078                 {
+02079                         // This one ?
+02080                         if (Elements[i].Element == child)
+02081                         {
+02082                                 // Add the field name
+02083                                 result += ".";
+02084                                 result += Elements[i].Name;
+02085                                 break;
+02086                         }
+02087                 }
+02088 
+02089                 // Draw some warning
+02090                 if (i==Elements.size ())
+02091                 {
+02092                         warning (false, "getFormName", "Child node not found.");
+02093                 }
+02094         }
+02095 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getIternalNodeByName CForm form,
const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array,
TNodeAction  action,
bool &  created,
bool &  parentVDfnArray,
bool  verbose,
uint32  round
[static, protected, inherited]
+
+ + + + + +
+   + + +

+Is createNode == Create, (*node)->Form must be == to the form argument. Is createNode == Return, form argument is not used, can be undefined.

+Only form, name, and action, must be defined. Then, else (*parentDfn / indexDfn ) or *node must be defined. Others value are for result only. +

+Definition at line 764 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::build(), NLGEORGES::CFormElm::Create, NLGEORGES::CFormElm::Delete, DfnFilename, NLGEORGES::CFormElmArray::Elements, NLGEORGES::CFormElmStruct::Elements, NLGEORGES::CFormDfn::Entries, NLGEORGES::CFormElmStruct::FormDfn, NLGEORGES::CFormDfn::CEntry::getArrayFlag(), NLGEORGES::CFormDfn::CEntry::getDfnPtr(), NLGEORGES::CFormDfn::getEntry(), NLGEORGES::CForm::getFilename(), NLGEORGES::CFormElm::getFormName(), NLGEORGES::CFormElmStruct::getFormName(), NLGEORGES::UFormElm::getNodeByName(), NLGEORGES::CForm::getParent(), NLGEORGES::CForm::getParentCount(), NLGEORGES::CForm::getRootNode(), NLGEORGES::CFormDfn::CEntry::getType(), NLGEORGES::CFormDfn::CEntry::getTypePtr(), NLGEORGES::CFormElm::isArray(), NLGEORGES::UFormElm::isVirtualStruct(), nlassert, NLGEORGES_MAX_RECURSION, nlstop, nlverify, NLGEORGES::CFormElm::Return, NLMISC::smprintf(), NLGEORGES::CFormElm::TokenArrayBegin, NLGEORGES::CFormElm::TokenArrayEnd, NLGEORGES::CFormElm::tokenize(), NLGEORGES::CFormElm::TokenPoint, NLGEORGES::CFormElm::TokenString, NLGEORGES::CType::Type, type, uint, uint32, NLGEORGES::CFormElm::unlink(), and NLGEORGES::CFormElm::warning(). +

+Referenced by NLGEORGES::CFormElm::arrayDeleteNodeByName(), NLGEORGES::CFormElm::arrayInsertNodeByName(), NLGEORGES::CFormElm::createNodeByName(), NLGEORGES::CFormElm::deleteNodeByName(), and NLGEORGES::CFormElm::getNodeByName(). +

+

00765 {
+00766         // *** Init output variables
+00767         created = false;
+00768         parentVDfnArray = false;
+00769         
+00770         // ParentDfn or Node..
+00771         nlassert ( (*parentDfn) || (*node) );
+00772 
+00773         // Error message
+00774         char error[512];
+00775 
+00776         // Parent exist ?
+00777         if (*parentDfn)
+00778         {
+00779                 // Get the entry
+00780                 const CFormDfn::CEntry &theEntry = (*parentDfn)->getEntry (indexDfn);
+00781 
+00782                 // Get the type
+00783                 type = theEntry.getType ();
+00784                 *nodeType = theEntry.getTypePtr ();
+00785                 if (type == UFormDfn::EntryVirtualDfn)
+00786                 {
+00787                         if (*node)
+00788                                 *nodeDfn = safe_cast <CFormElmVirtualStruct*> (*node)->FormDfn;
+00789                         else
+00790                                 *nodeDfn = NULL;
+00791                 }
+00792                 else
+00793                         *nodeDfn = theEntry.getDfnPtr ();
+00794                 array = theEntry.getArrayFlag ();
+00795         }
+00796         else if (*node)
+00797         {
+00798                 nlassert (!(*node)->isArray ());
+00799                 indexDfn = 0xffffffff;
+00800                 *nodeType = (*node)->isAtom () ? safe_cast<CFormElmAtom*>(*node)->Type : NULL;
+00801                 *nodeDfn = (*node)->isStruct () ? (const CFormDfn *)(safe_cast<CFormElmStruct*>(*node)->FormDfn) : NULL;
+00802                 type = (*node)->isAtom () ? UFormDfn::EntryType : (*node)->isVirtualStruct () ? UFormDfn::EntryVirtualDfn : UFormDfn::EntryDfn;
+00803                 array = false;
+00804         }
+00805 
+00806         // Check node pointer
+00807         if (action == Create)
+00808         {
+00809                 nlassert (*node);
+00810                 nlassert ((*node)->getForm () == form);
+00811         }
+00812 
+00813         // Backup current node
+00814         CFormElm *backupFirstElm = *node;
+00815 
+00816         // *** Parsing variables
+00817 
+00818         // Current token start and end
+00819         const char *startToken = name;
+00820         const char *endToken;
+00821 
+00822         // Current token start
+00823         string token;
+00824 
+00825         // Current form name
+00826         string currentName;
+00827         if (*node)
+00828                 (*node)->getFormName (currentName);
+00829 
+00830         // Error
+00831         uint errorIndex;
+00832 
+00833         // Token code
+00834         uint code;
+00835 
+00836         // Are we parsing an array ?
+00837         bool inArrayIndex = false;
+00838 
+00839         // Index in the array
+00840         uint arrayIndex;
+00841 
+00842         // Bool next token must be an array index
+00843         bool wantArrayIndex = false;
+00844 
+00845         // Last struct elm
+00846         CFormElmStruct *lastStructElm = ((*node)->ParentNode && (*node)->ParentNode->isStruct ()) ? safe_cast<CFormElmStruct*> ((*node)->ParentNode) : NULL;
+00847         uint lastStructIndex = 0;
+00848         if (lastStructElm)
+00849         {
+00850                 // Look for node in the parent
+00851                 for (; lastStructIndex<lastStructElm->Elements.size (); lastStructIndex++)
+00852                 {
+00853                         // The same node ?
+00854                         if (lastStructElm->Elements[lastStructIndex].Element == (*node))
+00855                                 break;
+00856                 }
+00857 
+00858                 // Must have been found
+00859                 nlassert (lastStructIndex<lastStructElm->Elements.size ());
+00860         }
+00861 
+00862         // While there is tokens
+00863         while ((endToken = tokenize (startToken, token, errorIndex, code)))
+00864         {
+00865                 // Ready an array index ?
+00866                 if (!inArrayIndex)
+00867                 {
+00868                         // For each code
+00869                         switch (code)
+00870                         {
+00871                         case TokenString:
+00872                                 {
+00873                                         // Need an array index array ?
+00874                                         if (wantArrayIndex)
+00875                                         {
+00876                                                 // Error message
+00877                                                 smprintf (error, 512, "Token (%s) should be an array index.", token.c_str());
+00878                                                 goto exit;
+00879                                         }
+00880 
+00881                                         // Are we a struct ?
+00882                                         if ( ((type == UFormDfn::EntryDfn) || (type == UFormDfn::EntryVirtualDfn)) /*&& (!array)*/ )
+00883                                         {
+00884                                                 // Check the virtual DFN is not empty..
+00885                                                 if ( (type == UFormDfn::EntryVirtualDfn) && (*nodeDfn == NULL) )
+00886                                                 {
+00887                                                         // Is it a parent virtual DFN ?
+00888                                                         if ( (type == UFormDfn::EntryVirtualDfn) && (*node == NULL) )
+00889                                                                 parentVDfnArray = true;
+00890 
+00891                                                         // Create mode ?
+00892                                                         if (action == Create)
+00893                                                         {
+00894                                                                 // Should have a valid node
+00895                                                                 nlassert (*node && lastStructElm);
+00896 
+00897                                                                 // Get the current virtual dfn
+00898                                                                 CFormElmVirtualStruct *vStruct = safe_cast<CFormElmVirtualStruct*> (*node);
+00899 
+00900                                                                 // Get the form name of the current node
+00901                                                                 string formName;
+00902                                                                 vStruct->getFormName (formName, NULL);
+00903 
+00904                                                                 // Get the parent node if available
+00905                                                                 for (uint parent=0; parent<form->getParentCount (); parent++)
+00906                                                                 {
+00907                                                                         // Get the parent
+00908                                                                         CForm *parentPtr = form->getParent (parent);
+00909                                                                         nlassert (parentPtr);
+00910 
+00911                                                                         // Get the virtual node by name
+00912                                                                         UFormElm *uelm;
+00913                                                                         if (parentPtr->getRootNode ().getNodeByName (&uelm, formName.c_str (), NULL, verbose, round+1) && uelm)
+00914                                                                         {
+00915                                                                                 // Value node ?
+00916                                                                                 if (uelm->isVirtualStruct ())
+00917                                                                                 {
+00918                                                                                         // Get a virtual struct pointer
+00919                                                                                         CFormElmVirtualStruct *vStructParent = safe_cast<CFormElmVirtualStruct*> (uelm);
+00920 
+00921                                                                                         // Copy the DFN filename
+00922                                                                                         vStruct->DfnFilename = vStructParent->DfnFilename;
+00923 
+00924                                                                                         // Build it
+00925                                                                                         vStruct->build (vStructParent->FormDfn);
+00926 
+00927                                                                                         // Set the current DFN
+00928                                                                                         *nodeDfn = vStruct->FormDfn;
+00929 
+00930                                                                                         // Stop looking for parent
+00931                                                                                         break;
+00932                                                                                 }
+00933                                                                                 else
+00934                                                                                 {
+00935                                                                                         // Error message
+00936                                                                                         smprintf (error, 512, "Internal node parsing error.");
+00937                                                                                         goto exit;
+00938                                                                                 }
+00939                                                                         }
+00940                                                                 }
+00941                                                         }
+00942 
+00943                                                         // Still no DFN ?
+00944                                                         if (*nodeDfn == NULL)
+00945                                                         {
+00946                                                                 // Error message
+00947                                                                 smprintf (error, 512, "Empty virtual struct element. Can't look into it while it is not defined.");
+00948                                                                 goto exit;
+00949                                                         }
+00950                                                 }
+00951 
+00952                                                 // Must hjave a nodeDfn here
+00953                                                 nlassert (*nodeDfn);
+00954 
+00955                                                 // Look for the element
+00956                                                 //                                              uint elementCount = (*nodeDfn)->getNumEntry ();
+00957 
+00958                                                 // Get the parents
+00959                                                 vector<const CFormDfn*> arrayDfn;
+00960                                                 arrayDfn.reserve ((*nodeDfn)->countParentDfn ());
+00961                                                 (*nodeDfn)->getParentDfn (arrayDfn);
+00962 
+00963                                                 // For each parent
+00964                                                 uint i;
+00965                                                 uint formElm = 0;
+00966                                                 for (i=0; i<arrayDfn.size(); i++)
+00967                                                 {
+00968                                                         // The dfn
+00969                                                         const CFormDfn &dfn = *(arrayDfn[i]);
+00970 
+00971                                                         // For each elements
+00972                                                         uint element;
+00973                                                         for (element=0; element<dfn.Entries.size(); element++)
+00974                                                         {
+00975                                                                 // Good name ?
+00976                                                                 if (dfn.Entries[element].Name == token)
+00977                                                                 {
+00978                                                                         // Good one.
+00979                                                                         *parentDfn = &dfn;
+00980                                                                         indexDfn = element;
+00981                                                                         *nodeDfn = dfn.Entries[element].Dfn;
+00982                                                                         *nodeType = dfn.Entries[element].Type;
+00983                                                                         type = dfn.Entries[element].TypeElement;
+00984                                                                         array = dfn.Entries[element].Array;
+00985                                                                         wantArrayIndex = array;
+00986 
+00987                                                                         // Next node
+00988                                                                         if (*node)
+00989                                                                         {
+00990                                                                                 // Get next node
+00991                                                                                 CFormElmStruct *nodeStruct = safe_cast<CFormElmStruct*> (*node);
+00992                                                                                 CFormElm *nextElt = nodeStruct->Elements[formElm].Element;
+00993                                                                                 
+00994                                                                                 // If no next node, watch for parent node
+00995                                                                                 *node = nextElt;
+00996 
+00997                                                                                 // Create node
+00998                                                                                 if ( (action == Create) && (*node == NULL) )
+00999                                                                                 {
+01000                                                                                         // Is an array ?
+01001                                                                                         if (array)
+01002                                                                                         {
+01003                                                                                                 // Create an atom
+01004                                                                                                 CFormElmArray *atom = new CFormElmArray (form, *nodeDfn, *nodeType, nodeStruct, *parentDfn, indexDfn);
+01005                                                                                                 *node = atom;
+01006                                                                                         }
+01007                                                                                         else
+01008                                                                                         {
+01009                                                                                                 // What kind of node ?
+01010                                                                                                 switch (type)
+01011                                                                                                 {
+01012                                                                                                 case UFormDfn::EntryType:
+01013                                                                                                         {
+01014                                                                                                                 // Create an atom
+01015                                                                                                                 CFormElmAtom *atom = new CFormElmAtom (form, nodeStruct, *parentDfn, indexDfn);
+01016                                                                                                                 *node = atom;
+01017                                                                                                         }
+01018                                                                                                         break;
+01019                                                                                                 case UFormDfn::EntryDfn:
+01020                                                                                                         {
+01021                                                                                                                 CFormElmStruct *_struct = new CFormElmStruct (form, nodeStruct, *parentDfn, indexDfn);
+01022                                                                                                                 _struct->build (*nodeDfn);
+01023                                                                                                                 *node = _struct;
+01024                                                                                                         }
+01025                                                                                                         break;
+01026                                                                                                 case UFormDfn::EntryVirtualDfn:
+01027                                                                                                         *node = new CFormElmVirtualStruct (form, nodeStruct, *parentDfn, indexDfn);
+01028                                                                                                         break;
+01029                                                                                                 default:
+01030                                                                                                         nlstop;
+01031                                                                                                 }
+01032                                                                                         }
+01033 
+01034                                                                                         // Node created
+01035                                                                                         created = true;
+01036 
+01037                                                                                         // Set the node in parent
+01038                                                                                         nodeStruct->Elements[formElm].Element = *node;
+01039                                                                                 }
+01040 
+01041                                                                                 // Is a virtual DFN ?
+01042                                                                                 if ((*node) && (*node)->isVirtualStruct ())
+01043                                                                                 {
+01044                                                                                         // Should be NULL
+01045                                                                                         nlassert (*nodeDfn == NULL);
+01046 
+01047                                                                                         // Set the current dfn
+01048                                                                                         *nodeDfn = safe_cast<const CFormElmVirtualStruct*> (*node)->FormDfn;
+01049                                                                                 }
+01050 
+01051                                                                                 // Save last struct
+01052                                                                                 lastStructElm = nodeStruct;
+01053                                                                                 lastStructIndex = formElm;
+01054                                                                         }
+01055                                                                         else
+01056                                                                         {
+01057                                                                                 // Save last struct
+01058                                                                           //                                                                            CFormElmStruct *lastStructElm = NULL;
+01059                                                                           //uint lastStructIndex = 0xffffffff;
+01060 
+01061                                                                                 *node = NULL;
+01062                                                                         }
+01063 
+01064                                                                         break;
+01065                                                                 }
+01066                                                                 formElm++;
+01067                                                         }
+01068 
+01069                                                         // Breaked ?
+01070                                                         if (element!=dfn.Entries.size())
+01071                                                                 break;
+01072                                                 }
+01073 
+01074                                                 // Breaked ?
+01075                                                 if (i==arrayDfn.size())
+01076                                                 {
+01077                                                         // Not found
+01078                                                         smprintf (error, 512, "Struct does not contain element named (%s).", token.c_str());
+01079                                                         goto exit;
+01080                                                 }
+01081                                         }
+01082                                         else
+01083                                         {
+01084                                                 // Error message
+01085                                                 smprintf (error, 512, "Not a struct element. Can't open the node (%s).", token.c_str());
+01086                                                 goto exit;
+01087                                         }
+01088                                 }
+01089                                 break;
+01090                         case TokenPoint:
+01091                                 {
+01092                                         // Need an array index array ?
+01093                                         if (wantArrayIndex)
+01094                                         {
+01095                                                 // Error message
+01096                                                 smprintf (error, 512, "Token (%s) should be an array index.", token.c_str());
+01097                                                 goto exit;
+01098                                         }
+01099 
+01100                                         // Are we a struct ?
+01101                                         if ((type != UFormDfn::EntryDfn) && (type != UFormDfn::EntryVirtualDfn))
+01102                                         {
+01103                                                 // Error message
+01104                                                 smprintf (error, 512, "Not a struct element. Can't open the node (%s).", token.c_str());
+01105                                                 goto exit;
+01106                                         }
+01107                                 }
+01108                                 break;
+01109                         case TokenArrayBegin:
+01110                                 {
+01111                                         // Are we an array ?
+01112                                         if (!array)
+01113                                         {
+01114                                                 // Error message
+01115                                                 smprintf (error, 512, "Not an array element. Can't open the node (%s).", token.c_str());
+01116                                                 goto exit;
+01117                                         }
+01118                                         inArrayIndex = true;
+01119                                         arrayIndex = 0xffffffff;
+01120                                 }
+01121                                 break;
+01122                         default:
+01123                                 {
+01124                                         // Error message
+01125                                         smprintf (error, 512, "Syntax error at keyword (%s).", token.c_str ());
+01126                                         goto exit;
+01127                                 }
+01128                                 break;
+01129                         }
+01130                 }
+01131                 else
+01132                 {
+01133                         switch (code)
+01134                         {
+01135                         case TokenString:
+01136                                 {
+01137                                         // To int
+01138                                         if (sscanf (token.c_str(), "%d", &arrayIndex)!=1)
+01139                                         {
+01140                                                 // Error message
+01141                                                 smprintf (error, 512, "Keyword (%s) is not an array index.", token.c_str());
+01142                                                 goto exit;
+01143                                         }
+01144 
+01145                                         // Is it a parent virtual DFN ?
+01146                                         if (*node == NULL)
+01147                                                 parentVDfnArray = true;
+01148 
+01149                                         // Should have an array defined
+01150                                         if (*node)
+01151                                         {
+01152                                                 // Check index
+01153                                                 uint arraySize;
+01154                                                 nlverify ((*node)->getArraySize (arraySize));
+01155                                                 if (arrayIndex>=arraySize)
+01156                                                 {
+01157                                                         // Create mode ?
+01158                                                         if (action == Create)
+01159                                                         {
+01160                                                                 // Must be in the same form
+01161                                                                 nlassert ((*node)->Form == form);
+01162 
+01163                                                                 // The array pointer
+01164                                                                 CFormElmArray *array = safe_cast<CFormElmArray*>(*node);
+01165                                                                 uint oldSize = array->Elements.size ();
+01166                                                                 array->Elements.resize (arrayIndex+1);
+01167 
+01168                                                                 // Insert empty element
+01169                                                                 uint i;
+01170                                                                 for (i=oldSize; i<array->Elements.size (); i++)
+01171                                                                 {
+01172                                                                         // The new element
+01173                                                                         CFormElm *newelm = NULL;
+01174                                                                         switch (type)
+01175                                                                         {
+01176                                                                         case UFormDfn::EntryType:
+01177                                                                                 {
+01178                                                                                         // Create an atom
+01179                                                                                         CFormElmAtom *atom = new CFormElmAtom (form, array, *parentDfn, indexDfn);
+01180                                                                                         newelm = atom;
+01181                                                                                 }
+01182                                                                                 break;
+01183                                                                         case UFormDfn::EntryDfn:
+01184                                                                                 {
+01185                                                                                         CFormElmStruct *_struct = new CFormElmStruct (form, array, *parentDfn, indexDfn);
+01186                                                                                         _struct->build (*nodeDfn);
+01187                                                                                         newelm = _struct;
+01188                                                                                 }
+01189                                                                                 break;
+01190                                                                         case UFormDfn::EntryVirtualDfn:
+01191                                                                                 // todo array of virtual struct
+01192                                                                                 //newelm = new CFormElmVirtualStruct (form, array, *parentDfn, indexDfn);
+01193                                                                                 break;
+01194                                                                         default:
+01195                                                                                 nlstop;
+01196                                                                         }
+01197 
+01198                                                                         nlassert (newelm);
+01199 
+01200                                                                         // Node created
+01201                                                                         created = true;
+01202 
+01203                                                                         // Set the element pointer
+01204                                                                         array->Elements[i].Element = newelm;
+01205                                                                 }
+01206                                                         }
+01207                                                         else
+01208                                                         {
+01209                                                                 // Error message
+01210                                                                 smprintf (error, 512, "Out of array bounds (%d >= %d).", arrayIndex, arraySize);
+01211                                                                 goto exit;
+01212                                                         }
+01213                                                 }
+01214                                         }
+01215                                         else
+01216                                         {
+01217                                                 // Error message
+01218                                                 smprintf (error, 512, "Array is not defined.");
+01219                                                 goto exit;
+01220                                         }
+01221                                 }
+01222                                 break;
+01223                         case TokenArrayEnd:
+01224                                 {
+01225                                         // No need of an array index any more
+01226                                         wantArrayIndex = false;
+01227 
+01228                                         // Index found ?
+01229                                         if (arrayIndex == 0xffffffff)
+01230                                         {
+01231                                                 // Error message
+01232                                                 smprintf (error, 512, "Missing array index.");
+01233                                         }
+01234                                         else
+01235                                         {
+01236                                                 // Let the parent DFN
+01237                                                 nlassert (*parentDfn);
+01238 
+01239                                                 // New current node
+01240                                                 CFormElmArray *parentNode = safe_cast<CFormElmArray*> (*node);
+01241 
+01242                                                 // Get the element
+01243                                                 *node = parentNode->Elements[arrayIndex].Element;
+01244 
+01245                                                 // Is a dfn ?
+01246                                                 *nodeDfn = (*parentDfn)->getEntry (indexDfn).getDfnPtr ();
+01247 
+01248                                                 // Is a type ?
+01249                                                 *nodeType = (*parentDfn)->getEntry (indexDfn).getTypePtr ();
+01250 
+01251                                                 // Type ?
+01252                                                 type = (*parentDfn)->getEntry (indexDfn).getType ();
+01253                                                 
+01254                                                 // Can't be an array of array
+01255                                                 array = false;
+01256 
+01257                                                 // Not any more in index
+01258                                                 inArrayIndex = false;
+01259 
+01260                                                 // What kind of node ?
+01261                                                 if ( (action == Create) && ( *node == NULL) )
+01262                                                 {
+01263                                                         switch (type)
+01264                                                         {
+01265                                                         case UFormDfn::EntryType:
+01266                                                                 {
+01267                                                                         // Create an atom
+01268                                                                         CFormElmAtom *atom = new CFormElmAtom (form, parentNode, *parentDfn, indexDfn);
+01269                                                                         *node = atom;
+01270                                                                 }
+01271                                                                 break;
+01272                                                         case UFormDfn::EntryDfn:
+01273                                                                 {
+01274                                                                         CFormElmStruct *_struct = new CFormElmStruct (form, parentNode, *parentDfn, indexDfn);
+01275                                                                         _struct->build (*nodeDfn);
+01276                                                                         *node = _struct;
+01277                                                                 }
+01278                                                                 break;
+01279                                                         case UFormDfn::EntryVirtualDfn:
+01280                                                                 // todo array of virtual struct
+01281                                                                 // *node = new CFormElmVirtualStruct (form, parentNode, *parentDfn, indexDfn);
+01282                                                                 break;
+01283                                                         default:
+01284                                                                 nlstop;
+01285                                                         }
+01286 
+01287                                                         nlassert (*node);
+01288 
+01289                                                         // Node created
+01290                                                         created = true;
+01291 
+01292                                                         // Set the element pointer
+01293                                                         parentNode->Elements[arrayIndex].Element = *node;
+01294                                                 }
+01295 
+01296                                                 // Is a virtual DFN ?
+01297                                                 if ((*node) && (*node)->isVirtualStruct ())
+01298                                                 {
+01299                                                         // Should be NULL
+01300                                                         nlassert (*nodeDfn == NULL);
+01301 
+01302                                                         // Set the current dfn
+01303                                                         *nodeDfn = safe_cast<const CFormElmVirtualStruct*> (*node)->FormDfn;
+01304                                                 }
+01305                                         }
+01306                                 }
+01307                                 break;
+01308                         default:
+01309                                 {
+01310                                         // Error message
+01311                                         smprintf (error, 512, "Keyword (%s) is not an array index.", token.c_str());
+01312                                         goto exit;
+01313                                 }
+01314                         }
+01315                 }
+01316 
+01317                 // Concat current adress
+01318                 currentName += token;
+01319                 startToken = endToken;
+01320         }
+01321 exit:;
+01322 
+01323         // Error ?
+01324         bool errorAppend = endToken != NULL;
+01325 
+01326         // Continue ?
+01327         if (!errorAppend)
+01328         {
+01329                 // Delete the node ?
+01330                 if ( (action == Delete) && (*node) )
+01331                 {
+01332                         // Get its parent
+01333                         CFormElm *parent = safe_cast<CFormElm*> ((*node)->getParent ());
+01334 
+01335                         // Don't erase the root structure
+01336                         if (parent && !parent->isArray ())
+01337                         {
+01338                                 // Unlink the primitive from its parent
+01339                                 parent->unlink (*node);
+01340 
+01341                                 // Erase the node
+01342                                 delete (*node);
+01343                                 *node = parent;
+01344                                 parent = (CFormElm*) (parent->getParent ());
+01345 
+01346                                 // For each parent
+01347                                 while (parent && !(*node)->isUsed (form) && !parent->isArray ())
+01348                                 {
+01349                                         // Unlink the primitive from its parent
+01350                                         parent->unlink (*node);
+01351 
+01352                                         // Erase it and get next parent
+01353                                         delete (*node);
+01354                                         *node = parent;
+01355                                         parent = (CFormElm*) (parent->getParent ());
+01356                                 }
+01357 
+01358                                 // No more node
+01359                                 *node = NULL;
+01360                         }
+01361                 }
+01362         }
+01363 
+01364         // Node not found in get node ? Look in parents !
+01365         if ( ((*node) == NULL) && (action == Return) && backupFirstElm )
+01366         {
+01367                 // Get the path name
+01368                 string formName;
+01369                 backupFirstElm->getFormName (formName);
+01370                 uint formNameSize = formName.size ();
+01371                 if ((formNameSize > 0) && (formName[formNameSize-1] != '.') && (formName[formNameSize-1] != '['))
+01372                         formName += ".";
+01373                 formName += name;
+01374 
+01375                 // Backup first parent default value
+01376                 bool defaultValue = false;
+01377                 const CFormDfn *defaultParentDfnParent=0;
+01378                 uint defaultIndexDfnParent=0;
+01379                 const CFormDfn *defaultNodeDfnParent=0;
+01380                 const CType *defaultNodeTypeParent=0;
+01381                 CFormElm *defaultNodeParent=0;
+01382                 UFormDfn::TEntryType defaultTypeParent = UFormDfn::EntryType;
+01383                 bool defaultArrayParent=false;
+01384                 bool defaultCreatedParent=false;
+01385                 bool defaultParentVDfnArray=false;
+01386 
+01387                 // Look in parent form
+01388                 for (uint parent=0; parent<form->getParentCount (); parent++)
+01389                 {
+01390                         // Get the parent
+01391                         CForm *parentPtr = form->getParent (parent);
+01392                         nlassert (parentPtr);
+01393 
+01394                         // Get the node by name in the parent
+01395                         const CFormDfn *parentDfnParent = NULL;
+01396                         uint indexDfnParent = 0xffffffff;
+01397                         const CFormDfn *nodeDfnParent = NULL;
+01398                         const CType *nodeTypeParent = NULL;
+01399                         CFormElm *nodeParent = (CFormElm*)&parentPtr->getRootNode ();
+01400                         UFormDfn::TEntryType typeParent;
+01401                         bool arrayParent;
+01402                         bool createdParent;
+01403                         bool parentVDfnArray;
+01404                         if (getIternalNodeByName (parentPtr, formName.c_str (), &parentDfnParent, indexDfnParent, &nodeDfnParent, &nodeTypeParent, &nodeParent, typeParent, arrayParent, action, createdParent, parentVDfnArray, false, round+1))
+01405                         {
+01406                                 // Node found ?
+01407                                 if (nodeParent)
+01408                                 {
+01409                                         // Found copy return values
+01410                                         *parentDfn = parentDfnParent;
+01411                                         indexDfn = indexDfnParent;
+01412                                         *nodeDfn = nodeDfnParent;
+01413                                         *nodeType = nodeTypeParent;
+01414                                         *node = nodeParent;
+01415                                         type = typeParent;
+01416                                         array = arrayParent;
+01417                                         created = createdParent;
+01418 
+01419                                         return true;
+01420                                 }
+01421                                 else 
+01422                                 {
+01423                                         // Backup the first parent default value found
+01424                                         if (!defaultValue)
+01425                                         {
+01426                                                 defaultParentDfnParent = parentDfnParent;
+01427                                                 defaultIndexDfnParent = indexDfnParent;
+01428                                                 defaultNodeDfnParent = nodeDfnParent;
+01429                                                 defaultNodeTypeParent = nodeTypeParent;
+01430                                                 defaultNodeParent = nodeParent;
+01431                                                 defaultTypeParent = typeParent;
+01432                                                 defaultArrayParent = arrayParent;
+01433                                                 defaultCreatedParent = createdParent;
+01434                                                 defaultParentVDfnArray = parentVDfnArray;
+01435                                                 defaultValue = true;
+01436                                         }
+01437                                 }
+01438                         }
+01439                 }
+01440 
+01441                 // Default value available ?
+01442                 if (defaultValue)
+01443                 {
+01444                         *parentDfn = defaultParentDfnParent;
+01445                         indexDfn = defaultIndexDfnParent;
+01446                         *nodeDfn = defaultNodeDfnParent;
+01447                         *nodeType = defaultNodeTypeParent;
+01448                         *node = defaultNodeParent;
+01449                         type = defaultTypeParent;
+01450                         array = defaultArrayParent;
+01451                         created = defaultCreatedParent;
+01452                         return true;
+01453                 }
+01454         }
+01455 
+01456         // Recurce warning !
+01457         if (*node)
+01458         {
+01459                 if (round > NLGEORGES_MAX_RECURSION)
+01460                 {
+01461                         // Turn around..
+01462                         string formName;
+01463                         (*node)->getFormName (formName);
+01464                         warning (false, formName.c_str (), form->getFilename ().c_str(), "getIternalNodeByName", "Recurcive call on the same node (%s), look for loop references or inheritances.", name);
+01465                         return false;
+01466                 }
+01467         }
+01468 
+01469         if (verbose && errorAppend)
+01470         {
+01471                 nlassert (*error);
+01472 
+01473                 // Get the best form name
+01474                 warning (false, currentName.c_str (), form->getFilename ().c_str(), "getIternalNodeByName", "Getting the node (%s) : %s", name, error);
+01475         }
+01476 
+01477         return !errorAppend;
+01478 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getNodeByName const char *  name,
const CFormDfn **  parentDfn,
uint indexDfn,
const CFormDfn **  nodeDfn,
const CType **  nodeType,
CFormElm **  node,
UFormDfn::TEntryType type,
bool &  array,
bool &  parentVDfnArray,
bool  verbose,
uint32  round
const [inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 629 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElm::ParentDfn, NLGEORGES::CFormElm::ParentIndex, NLGEORGES::CFormElm::Return, type, uint, and uint32. +

+

00633 {
+00634         *parentDfn = ParentDfn;
+00635         indexDfn = ParentIndex;
+00636         *nodeDfn = NULL;
+00637         *nodeType = NULL;
+00638         *node = (CFormElm*)this;
+00639         bool created;
+00640         return getIternalNodeByName (Form, name, parentDfn, indexDfn, nodeDfn, nodeType, node, type, array, Return, created, parentVDfnArray, verbose, round);
+00641 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getNodeByName UFormElm **  result,
const char *  name,
TWhereIsNode where,
bool  verbose,
uint32  round = 0
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 360 of file form_elm.cpp. +

+References uint32. +

+

00361 {
+00362         const UFormElm *resultConst = NULL;
+00363         if (((const UFormElm*)this)->getNodeByName (&resultConst, name, where, verbose, round))
+00364         {
+00365                 *result = const_cast<UFormElm*> (resultConst);
+00366                 return true;
+00367         }
+00368         return false;
+00369 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getNodeByName const UFormElm **  result,
const char *  name,
TWhereIsNode where,
bool  verbose,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return a node pointer with its name.

+

Parameters:
+ + + + +
result will be filled with the node pointer. Can be NULL if the node doesn't exist.
name is the form node name
where is a pointer on the information flag of the value. If Where is not NULL, it is filled with the position where the node has been found. If result is NULL, where is undefined.
+
+
Returns:
true if the result has been filled, false if the node is not referenced.
+About the node existance

+An atom node exist if its value are defined. A struct node exist if one of its children exist. An array node exist if one of its children exist. If the node doesn't exist, you can't have a pointer on it with getNodeByName(). It returns NULL. But, you can evaluate the value of non-existant atom nodes with getValueByName().

+About the form name:

+Struct elements name must be separeted by '.' Struct indexes must be between '[' and ']'

+Exemple: "position.x" : get the element named x in the struct named position "entities[2].color" : get the node named color in the second element of the entities array +

+Implements NLGEORGES::UFormElm. +

+Definition at line 373 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Form, type, uint, and uint32. +

+Referenced by NLGEORGES::CFormElm::getValueByName(). +

+

00374 {
+00375         // The parent Dfn
+00376         const CFormDfn *parentDfn;
+00377         const CFormDfn *nodeDfn;
+00378         const CType *nodeType;
+00379         CFormElm *node;
+00380         uint indexDfn;
+00381         bool array;
+00382         bool parentVDfnArray;
+00383         UFormDfn::TEntryType type;
+00384 
+00385         // Search for the node
+00386         if (getNodeByName (name, &parentDfn, indexDfn, &nodeDfn, &nodeType, &node, type, array, parentVDfnArray, verbose, round))
+00387         {
+00388                 // Set the result
+00389                 *result = node;
+00390 
+00391                 // Where ?
+00392                 if (where && node)
+00393                 {
+00394                         *where = (node->getForm () == Form) ? NodeForm : NodeParentForm;
+00395                 }
+00396 
+00397                 // Ok 
+00398                 return true;
+00399         }
+00400 
+00401         return false;
+00402 }
+
+

+ + + + +
+ + + + + + + + + +
UFormElm * NLGEORGES::CFormElm::getParent  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 589 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::ParentNode. +

+

00590 {
+00591         return ParentNode;
+00592 }
+
+

+ + + + +
+ + + + + + + + + +
UFormDfn * NLGEORGES::CFormElmStruct::getStructDfn  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Return the struct dfn. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1762 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::FormDfn. +

+

01763 {
+01764         return (CFormDfn*)FormDfn;
+01765 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElmStruct::getStructNode uint  element,
UFormElm **  result
[virtual, inherited]
+
+ + + + + +
+   + + +

+Return a mutable element pointer. Can be NULL if the node doesn't exist. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1769 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElmStruct::warning(). +

+

01770 {
+01771         if (element<Elements.size())
+01772         {
+01773                 *result = Elements[element].Element;
+01774                 return true; 
+01775         }
+01776         else
+01777         {
+01778                 warning (false, "getStructNode", "Index (%d) out of bound (%d).", element, Elements.size() );
+01779                 return false;
+01780         }
+01781 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElmStruct::getStructNode uint  element,
const UFormElm **  result
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return a const element pointer. Can be NULL if the node doesn't exist. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1746 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElmStruct::warning(). +

+

01747 {
+01748         if (element<Elements.size())
+01749         {
+01750                 *result = Elements[element].Element;
+01751                 return true; 
+01752         }
+01753         else
+01754         {
+01755                 warning (false, "getStructNode", "Index (%d) out of bound (%d).", element, Elements.size() );
+01756                 return false;
+01757         }
+01758 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElmStruct::getStructNodeName uint  element,
std::string &  result
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return the element name. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1730 of file form_elm.cpp. +

+References uint, and NLGEORGES::CFormElmStruct::warning(). +

+

01731 {
+01732         if (element<Elements.size())
+01733         {
+01734                 result = Elements[element].Name;
+01735                 return true;
+01736         }
+01737         else
+01738         {
+01739                 warning (false, "getStructNodeName", "Index (%d) out of bound (%d).", element, Elements.size() );
+01740                 return false;
+01741         }
+01742 };
+
+

+ + + + +
+ + + + + + + + + + +
bool NLGEORGES::CFormElmStruct::getStructSize uint size  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return the struct size. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1722 of file form_elm.cpp. +

+References size, and uint. +

+

01723 {
+01724         size = Elements.size();
+01725         return true;
+01726 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue NLMISC::CRGBA resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Warning, only R, G and B members are filled, not A. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 320 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::warning(). +

+

00321 {
+00322         warning (false, "getValue", "This node is not an atom."); 
+00323         return false; 
+00324 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue bool &  resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 312 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::warning(). +

+

00313 {
+00314         warning (false, "getValue", "This node is not an atom."); 
+00315         return false; 
+00316 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue double &  resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 304 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::warning(). +

+

00305 {
+00306         warning (false, "getValue", "This node is not an atom."); 
+00307         return false; 
+00308 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue float &  resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 296 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::warning(). +

+

00297 {
+00298         warning (false, "getValue", "This node is not an atom.");
+00299         return false; 
+00300 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue uint32 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 288 of file form_elm.cpp. +

+References uint32, and NLGEORGES::CFormElm::warning(). +

+

00289 {
+00290         warning (false, "getValue", "This node is not an atom.");
+00291         return false; 
+00292 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue sint32 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 280 of file form_elm.cpp. +

+References sint32, and NLGEORGES::CFormElm::warning(). +

+

00281 {
+00282         warning (false, "getValue", "This node is not an atom.");
+00283         return false; 
+00284 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue uint16 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 272 of file form_elm.cpp. +

+References uint16, and NLGEORGES::CFormElm::warning(). +

+

00273 {
+00274         warning (false, "getValue", "This node is not an atom.");
+00275         return false; 
+00276 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue sint16 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 264 of file form_elm.cpp. +

+References sint16, and NLGEORGES::CFormElm::warning(). +

+

00265 {
+00266         warning (false, "getValue", "This node is not an atom.");
+00267         return false; 
+00268 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue uint8 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 256 of file form_elm.cpp. +

+References uint8, and NLGEORGES::CFormElm::warning(). +

+

00257 {
+00258         warning (false, "getValue", "This node is not an atom.");
+00259         return false; 
+00260 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue sint8 resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 248 of file form_elm.cpp. +

+References sint8, and NLGEORGES::CFormElm::warning(). +

+

00249 {
+00250         warning (false, "getValue", "This node is not an atom.");
+00251         return false; 
+00252 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValue std::string &  resultname,
TEval  evaluate
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return the atom value. The numbers are clamped to the type limit values.

+

Parameters:
+ + + +
result is the reference on the value to fill with result
evaluate must be true if you want to have an evaluated value, false if you want the formula value.
+
+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 240 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::warning(). +

+

00241 { 
+00242         warning (false, "getValue", "This node is not an atom.");
+00243         return false; 
+00244 };
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName NLMISC::CRGBA result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Warning, only R, G and B members are filled, not A. +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 575 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, and value. +

+

00576 {
+00577         // Get the string value
+00578         string value;
+00579         if (getValueByName (value, name, evaluate, where, round))
+00580         {
+00581                 return convertValue (result, value.c_str ());
+00582         }
+00583 
+00584         return false;
+00585 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName bool &  result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 561 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, and value. +

+

00562 {
+00563         // Get the string value
+00564         string value;
+00565         if (getValueByName (value, name, evaluate, where, round))
+00566         {
+00567                 return convertValue (result, value.c_str ());
+00568         }
+00569 
+00570         return false;
+00571 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName double &  result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 547 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, and value. +

+

00548 {
+00549         // Get the string value
+00550         string value;
+00551         if (getValueByName (value, name, evaluate, where, round))
+00552         {
+00553                 return convertValue (result, value.c_str ());
+00554         }
+00555 
+00556         return false;
+00557 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName float &  result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 533 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, and value. +

+

00534 {
+00535         // Get the string value
+00536         string value;
+00537         if (getValueByName (value, name, evaluate, where, round))
+00538         {
+00539                 return convertValue (result, value.c_str ());
+00540         }
+00541 
+00542         return false;
+00543 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName uint32 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 519 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, and value. +

+

00520 {
+00521         // Get the string value
+00522         string value;
+00523         if (getValueByName (value, name, evaluate, where, round))
+00524         {
+00525                 return convertValue (result, value.c_str ());
+00526         }
+00527 
+00528         return false;
+00529 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName sint32 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 505 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), sint32, uint32, and value. +

+

00506 {
+00507         // Get the string value
+00508         string value;
+00509         if (getValueByName (value, name, evaluate, where, round))
+00510         {
+00511                 return convertValue (result, value.c_str ());
+00512         }
+00513 
+00514         return false;
+00515 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName uint16 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 491 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint16, uint32, and value. +

+

00492 {
+00493         // Get the string value
+00494         string value;
+00495         if (getValueByName (value, name, evaluate, where, round))
+00496         {
+00497                 return convertValue (result, value.c_str ());
+00498         }
+00499 
+00500         return false;
+00501 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName sint16 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 477 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), sint16, uint32, and value. +

+

00478 {
+00479         // Get the string value
+00480         string value;
+00481         if (getValueByName (value, name, evaluate, where, round))
+00482         {
+00483                 return convertValue (result, value.c_str ());
+00484         }
+00485 
+00486         return false;
+00487 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName uint8 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 463 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), uint32, uint8, and value. +

+

00464 {
+00465         // Get the string value
+00466         string value;
+00467         if (getValueByName (value, name, evaluate, where, round))
+00468         {
+00469                 return convertValue (result, value.c_str ());
+00470         }
+00471 
+00472         return false;
+00473 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName sint8 result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 449 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getValueByName(), sint8, uint32, and value. +

+

00450 {
+00451         // Get the string value
+00452         string value;
+00453         if (getValueByName (value, name, evaluate, where, round))
+00454         {
+00455                 return convertValue (result, value.c_str ());
+00456         }
+00457 
+00458         return false;
+00459 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::getValueByName std::string &  result,
const char *  name,
TEval  evaluate,
TWhereIsValue where,
uint32  round = 0
const [virtual, inherited]
+
+ + + + + +
+   + + +

+Get a form value with its name. The numbers are clamped to the type limit values.

+

Parameters:
+ + + + + +
result is a reference on the value to fill with the result.
name is the form name of the value to found.
evaluate must be true if you want to have an evaluated value, false if you want the formula value.
where is a pointer on the information flag of the value. If Where is not NULL, it is filled with the position where the value has been found.
+
+
Returns:
true if the result has been filled, false if the value has not been found or the cast has failed or the evaluation has failed.
+
See also:
getNodeByName ()
+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 406 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::Form, NLGEORGES::CFormElm::getNodeByName(), NLGEORGES::CType::getValue(), nlassert, type, uint, uint32, and NLGEORGES::CFormElm::warning(). +

+Referenced by NLGEORGES::CFormElm::getValueByName(). +

+

00407 {
+00408         // The parent Dfn
+00409         const CFormDfn *parentDfn;
+00410         const CFormDfn *nodeDfn;
+00411         const CType *nodeType;
+00412         CFormElm *node;
+00413         uint parentIndex;
+00414         bool array;
+00415         bool parentVDfnArray;
+00416         UFormDfn::TEntryType type;
+00417 
+00418         // Search for the node
+00419         if (getNodeByName (name, &parentDfn, parentIndex, &nodeDfn, &nodeType, &node, type, array, parentVDfnArray, true, round))
+00420         {
+00421                 // End, return the current index
+00422                 if (type == UFormDfn::EntryType)
+00423                 {
+00424                         // The atom
+00425                         const CFormElmAtom *atom = node ? safe_cast<const CFormElmAtom*> (node) : NULL;
+00426 
+00427                         // Evale
+00428                         nlassert (nodeType);
+00429                         return (nodeType->getValue (result, Form, atom, *parentDfn, parentIndex, evaluate, (uint32*)where, round, name));
+00430                 }
+00431                 else
+00432                 {
+00433                         // Error message
+00434                         warning (false, "getValueByName", "The node (%s) is not an atom element. Can't return a value.", name);
+00435                 }
+00436         }
+00437         else
+00438         {
+00439                 // Error message
+00440                 warning (false, "getValueByName", "Can't find the node (%s).", name);
+00441         }
+00442 
+00443         // Error
+00444         return false;
+00445 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLGEORGES::CFormElm::isArray  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the element is an array. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmArray. +

+Definition at line 53 of file form_elm.cpp. +

+Referenced by NLGEORGES::CFormElm::arrayDeleteNodeByName(), NLGEORGES::CFormElm::arrayInsertNodeByName(), and NLGEORGES::CFormElm::getIternalNodeByName(). +

+

00054 { 
+00055         return false; 
+00056 };
+
+

+ + + + +
+ + + + + + + + + +
bool NLGEORGES::CFormElm::isAtom  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the element is an atom. +

+ +

+Implements NLGEORGES::UFormElm. +

+Reimplemented in NLGEORGES::CFormElmAtom. +

+Definition at line 233 of file form_elm.cpp. +

+

00234 { 
+00235         return false; 
+00236 };
+
+

+ + + + +
+ + + + + + + + + +
bool NLGEORGES::CFormElmStruct::isStruct  )  const [virtual, inherited]
+
+ + + + + +
+   + + +

+Return true if the element is a struct or a virtual struct. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 1715 of file form_elm.cpp. +

+

01716 {
+01717         return true;
+01718 };
+
+

+ + + + +
+ + + + + + + + + + +
bool NLGEORGES::CFormElmVirtualStruct::isUsed const CForm form  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLGEORGES::CFormElmStruct. +

+Definition at line 2223 of file form_elm.cpp. +

+Referenced by write(). +

+

02224 {
+02225         return true;
+02226 }
+
+

+ + + + +
+ + + + + + + + + +
bool NLGEORGES::CFormElmVirtualStruct::isVirtualStruct  )  const [virtual]
+
+ + + + + +
+   + + +

+Return true if the element is a virtual struct. +

+ +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 2208 of file form_elm.cpp. +

+

02209 {
+02210         return true;
+02211 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLGEORGES::CFormElmStruct::read xmlNodePtr  node,
CFormLoader loader,
const CFormDfn dfn,
CForm form
[inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 1817 of file form_elm.cpp. +

+References NLGEORGES::CFormElmStruct::build(), NLGEORGES::CFormElmStruct::CFormElmStruct(), NLGEORGES::CFormDfn::countParentDfn(), NLGEORGES::CFormElmStruct::FormDfn, NLGEORGES::CFormDfn::getParentDfn(), nlassert, read(), NLGEORGES::CFormElmAtom::read(), NLGEORGES::CFormElmArray::read(), uint, and NLGEORGES::CFormElmStruct::warning(). +

+Referenced by NLGEORGES::CFormElmArray::read(), and NLGEORGES::CForm::read(). +

+

01818 {
+01819         // Get the smart pointer on the dfn
+01820         FormDfn = (CFormDfn*)dfn;
+01821 
+01822         // Build the Form
+01823         build (dfn);
+01824 
+01825         // Count parent
+01826         uint dfnCount = dfn->countParentDfn ();
+01827 
+01828         // Array of Dfn
+01829         std::vector<const CFormDfn*> dfnArray;
+01830         dfnArray.reserve (dfnCount);
+01831         dfn->getParentDfn (dfnArray);
+01832 
+01833         // For each Dfn
+01834         uint dfnId;
+01835         uint elmIndex=0;
+01836         for (dfnId=0; dfnId<dfnCount; dfnId++)
+01837         {
+01838                 // Lookup for the name in the DFN
+01839                 uint elm;
+01840                 for (elm=0; elm<dfnArray[dfnId]->Entries.size(); elm++)
+01841                 {
+01842                         // Found ?
+01843                   //                    bool found = false;
+01844 
+01845                         // Read the struct
+01846                         xmlNodePtr child = NULL;
+01847 
+01848                         // Node can be NULL
+01849                         if (node)
+01850                                 child = node->children;
+01851 
+01852                         while (child)
+01853                         {
+01854                                 // Good node ?
+01855                                 const char *name = (const char*)xmlGetProp (child, (xmlChar*)"Name");
+01856                                 if (name && (dfnArray[dfnId]->Entries[elm].getName () == name) )
+01857                                 {
+01858                                         // Type
+01859                                         bool atom=false;
+01860                                         bool array=false;
+01861                                         bool _struct=false;
+01862                                         bool vStruct=false;
+01863 
+01864                                         // Is an atom ?
+01865                                         if (strcmp ((const char*)child->name, "ATOM") == 0)
+01866                                         {
+01867                                                 atom = true;
+01868                                         }
+01869                                         // Is a struct ?
+01870                                         else if (strcmp ((const char*)child->name, "STRUCT") == 0)
+01871                                         {
+01872                                                 _struct = true;
+01873                                         }
+01874                                         // Is a struct ?
+01875                                         else if (strcmp ((const char*)child->name, "VSTRUCT") == 0)
+01876                                         {
+01877                                                 vStruct = true;
+01878                                         }
+01879                                         // Is an array ?
+01880                                         else if (strcmp ((const char*)child->name, "ARRAY") == 0)
+01881                                         {
+01882                                                 array = true;
+01883                                         }
+01884 
+01885                                         // Continue ?
+01886                                         if (atom || _struct || vStruct || array)
+01887                                         {
+01888                                                 // Same type ?
+01889                                                 if ( 
+01890                                                         (atom && (dfnArray[dfnId]->Entries[elm].getType ()==UFormDfn::EntryType) && (!dfnArray[dfnId]->Entries[elm].getArrayFlag ()) ) || 
+01891                                                         (array && dfnArray[dfnId]->Entries[elm].getArrayFlag () && ( (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryType) || (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryDfn) ) ) || 
+01892                                                         (_struct && (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryDfn) && (!dfnArray[dfnId]->Entries[elm].getArrayFlag ()) ) ||
+01893                                                         (vStruct && (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryVirtualDfn) && (!dfnArray[dfnId]->Entries[elm].getArrayFlag ()) )
+01894                                                         )
+01895                                                 {
+01896                                                         // Ok keep it
+01897                                                         xmlFree((void*) name);
+01898                                                         break;
+01899                                                 }
+01900                                                 else
+01901                                                 {
+01902                                                         // Make a warning message
+01903                                                         warning (false, "read", "In block line %d, node (%s) type in DFN have changed.",
+01904                                                                 (int)child->content, child->name);
+01905                                                 }
+01906                                         }
+01907                                         else
+01908                                         {
+01909                                                 if (name)
+01910                                                 {
+01911                                                         // Delete the value
+01912                                                         xmlFree ((void*)name);
+01913                                                 }
+01914 
+01915                                                 // Throw exception
+01916                                                 warning (true, "read", "XML Syntax error in block line %d, node (%s) name should be STRUCT, ATOM or ARRAY.", 
+01917                                                         (int)child->content, child->name);
+01918                                         }
+01919                                 }
+01920 
+01921                                 if (name)
+01922                                 {
+01923                                         // Delete the value
+01924                                         xmlFree ((void*)name);
+01925                                 }
+01926 
+01927                                 // Next child
+01928                                 child = child->next;
+01929                         }
+01930 
+01931                         // Found ?
+01932                         if (child)
+01933                         {
+01934                                 // Create a new element
+01935                                 if (dfnArray[dfnId]->Entries[elm].getArrayFlag ())
+01936                                 {
+01937                                         // Array of type
+01938                                         CFormElmArray *newElm = NULL;
+01939                                         if (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryType)
+01940                                         {
+01941                                                 // Load the new element
+01942                                                 newElm = new CFormElmArray (form, NULL, dfnArray[dfnId]->Entries[elm].getTypePtr (), this, dfnArray[dfnId], elm);
+01943                                         }
+01944                                         // Array of struct
+01945                                         else if (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryDfn)
+01946                                         {
+01947                                                 newElm = new CFormElmArray (form, dfnArray[dfnId]->Entries[elm].getDfnPtr (), NULL, this, dfnArray[dfnId], elm);
+01948                                         }
+01949 
+01950                                         // Should be created
+01951                                         nlassert (newElm);
+01952                                         Elements[elmIndex].Element = newElm;
+01953                                         newElm->read (child, loader, form);
+01954                                 }
+01955                                 else if (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryType)
+01956                                 {
+01957                                         // Load the new element
+01958                                         CFormElmAtom *newElm = new CFormElmAtom (form, this, dfnArray[dfnId], elm);
+01959                                         Elements[elmIndex].Element = newElm;
+01960                                         newElm->read (child, loader, dfnArray[dfnId]->Entries[elm].getTypePtr (), form);
+01961                                 }
+01962                                 else if (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryDfn)
+01963                                 {
+01964                                         // Load the new element
+01965                                         CFormElmStruct *newElm = new CFormElmStruct (form, this, dfnArray[dfnId], elm);
+01966                                         Elements[elmIndex].Element = newElm;
+01967                                         newElm->read (child, loader, dfnArray[dfnId]->Entries[elm].getDfnPtr (), form);
+01968                                 }
+01969                                 else // if dfnArray[dfnId]->Entries[elm].getType () == CFormDfn::CEntry::EntryVirtualDfn)
+01970                                 {
+01971                                         // Should be a struct
+01972                                         nlassert (dfnArray[dfnId]->Entries[elm].getType () == UFormDfn::EntryVirtualDfn);
+01973 
+01974                                         // Load the new element
+01975                                         CFormElmVirtualStruct *newElm = new CFormElmVirtualStruct (form, this, dfnArray[dfnId], elm);
+01976                                         Elements[elmIndex].Element = newElm;
+01977                                         newElm->read (child, loader, form);
+01978                                 }
+01979                         }
+01980                         else
+01981                                 Elements[elmIndex].Element = NULL;
+01982 
+01983                         elmIndex++;
+01984                 }
+01985         }
+01986 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NLGEORGES::CFormElmVirtualStruct::read xmlNodePtr  node,
CFormLoader loader,
CForm form
+
+ + + + + +
+   + + +

+ +

+Definition at line 2175 of file form_elm.cpp. +

+References DfnFilename, NLGEORGES::CFormLoader::loadFormDfn(), and warning(). +

+Referenced by NLGEORGES::CFormElmStruct::read(). +

+

02176 {
+02177         // Get the DFN filename
+02178         const char *filename = (const char*)xmlGetProp (node, (xmlChar*)"DfnName");
+02179         if (filename)
+02180         {
+02181                 // Set the name
+02182                 DfnFilename = filename;
+02183 
+02184                 // Delete the value
+02185                 xmlFree ((void*)filename);
+02186 
+02187                 // Load the dfn
+02188                 FormDfn = loader.loadFormDfn (DfnFilename.c_str (), false);
+02189                 if (!FormDfn)
+02190                 {
+02191                         // Throw exception
+02192                         warning (true, "read", "Can't find DFN filename (%s).", DfnFilename.c_str ());
+02193                 }
+02194         }
+02195         else
+02196         {
+02197                 // Throw exception
+02198                 warning (true, "read", "XML Syntax error in virtual struct in block line %d, should have a DfnName property.", 
+02199                         (int)node->content, node->name);
+02200         }
+02201 
+02202         // Read the parent
+02203         CFormElmStruct::read (node, loader, FormDfn, form);
+02204 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName NLMISC::CRGBA  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1647 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::smprintf(), and value. +

+

01648 {       
+01649         char tmp[512];
+01650         smprintf (tmp, 512, "%d,%d,%d", value.R, value.G, value.B);
+01651         return setValueByName (tmp, name, created);
+01652 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName bool  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1640 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), and value. +

+

01641 {
+01642         return setValueByName (toString (value).c_str (), name, created);
+01643 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName double  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1633 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), and value. +

+

01634 {
+01635         return setValueByName (toString (value).c_str (), name, created);
+01636 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName float  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1626 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), and value. +

+

01627 {
+01628         return setValueByName (toString (value).c_str (), name, created);
+01629 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName uint32  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1619 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), uint32, and value. +

+

01620 {
+01621         return setValueByName (toString (value).c_str (), name, created);
+01622 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName sint32  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1612 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), sint32, NLMISC::toString(), and value. +

+

01613 {
+01614         return setValueByName (toString (value).c_str (), name, created);
+01615 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName uint16  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1605 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), uint16, and value. +

+

01606 {
+01607         return setValueByName (toString (value).c_str (), name, created);
+01608 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName sint16  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1598 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), sint16, NLMISC::toString(), and value. +

+

01599 {
+01600         return setValueByName (toString (value).c_str (), name, created);
+01601 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName uint8  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1591 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), NLMISC::toString(), uint8, and value. +

+

01592 {
+01593         return setValueByName (toString (value).c_str (), name, created);
+01594 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName sint8  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1584 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::setValueByName(), sint8, NLMISC::toString(), and value. +

+

01585 {
+01586         return setValueByName (toString (value).c_str (), name, created);
+01587 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool NLGEORGES::CFormElm::setValueByName const char *  value,
const char *  name,
bool *  created
[virtual, inherited]
+
+ + + + + +
+   + + +

+Set a form value with its name. If the node doesn't exist, it is created.

+

Parameters:
+ + + + + +
value is a reference on the value to set in the form.
name is the form name of the value to set or create.
where is a pointer on the information flag of the value. If Where is not NULL, it is filled with the position where the value has been found.
created is a pointer on the creatation flag. If created is not NULL, it is filled with true if the value has been created, false it the value has been filled.
+
+
Returns:
true if the value has been set, false if the value has not been found or hasn't been created.
+ +

+Implements NLGEORGES::UFormElm. +

+Definition at line 1532 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::createNodeByName(), nlassert, NLGEORGES::CFormElmAtom::setValue(), type, uint, value, and NLGEORGES::CFormElm::warning(). +

+Referenced by NLGEORGES::CFormElm::setValueByName(). +

+

01533 {
+01534         // The parent Dfn
+01535         const CFormDfn *parentDfn;
+01536         const CFormDfn *nodeDfn;
+01537         const CType *nodeType;
+01538         CFormElm *node;
+01539         uint indexDfn;
+01540         bool array;
+01541         bool _created;
+01542         UFormDfn::TEntryType type;
+01543 
+01544         // Search for the node
+01545         if (createNodeByName (name, &parentDfn, indexDfn, &nodeDfn, &nodeType, &node, type, array, _created))
+01546         {
+01547                 // Is this a type ?
+01548                 if (type == UFormDfn::EntryType)
+01549                 {
+01550                         // The atom
+01551                         CFormElmAtom *atom = node ? safe_cast<CFormElmAtom*> (node) : NULL;
+01552 
+01553                         // Evale
+01554                         nlassert (nodeType);
+01555                         atom->setValue (value);
+01556 
+01557                         // Created flag
+01558                         if (created)
+01559                                 *created = _created;
+01560                         return true;
+01561                 }
+01562                 else
+01563                 {
+01564                         // Error message
+01565                         warning (false, "setValueByName", "The node (%s) is not an atom element. Can't set the value.", name);
+01566                 }
+01567         }
+01568         else
+01569         {
+01570                 // Error message
+01571                 warning (false, "setValueByName", "Can't created / set the node (%s).", name);
+01572 
+01573                 // Created flag
+01574                 if (created)
+01575                         *created = false;
+01576         }
+01577 
+01578         // Error
+01579         return false;
+01580 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
const char * NLGEORGES::CFormElm::tokenize const char *  name,
std::string &  str,
uint errorIndex,
uint code
[static, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 1482 of file form_elm.cpp. +

+References NLGEORGES::CFormElm::TokenArrayBegin, NLGEORGES::CFormElm::TokenArrayEnd, NLGEORGES::CFormElm::TokenPoint, NLGEORGES::CFormElm::TokenString, and uint. +

+Referenced by NLGEORGES::CFormElm::getIternalNodeByName(). +

+

01483 {
+01484         if (*name == 0)
+01485         {
+01486                 return NULL;
+01487         }
+01488 
+01489         if (*name == '[')
+01490         {
+01491                 code = TokenArrayBegin;
+01492                 str = "[";
+01493                 return name+1;
+01494         }
+01495 
+01496         if (*name == ']')
+01497         {
+01498                 code = TokenArrayEnd;
+01499                 str = "]";
+01500                 return name+1;
+01501         }
+01502 
+01503         if (*name == '.')
+01504         {
+01505                 code = TokenPoint;
+01506                 str = ".";
+01507                 return name+1;
+01508         }
+01509 
+01510         str = "";
+01511         while ( (*name != '.') && (*name != '[') && (*name != ']') && (*name != 0) )
+01512         {
+01513                 // Add a char
+01514                 str += *name;
+01515                 name++;
+01516         }
+01517 
+01518         code = TokenString;
+01519         return name;
+01520 }
+
+

+ + + + +
+ + + + + + + + + + +
void NLGEORGES::CFormElmStruct::unlink CFormElm child  )  [virtual, inherited]
+
+ + + + + +
+   + + +

+Unlink a child +

+Reimplemented from NLGEORGES::CFormElm. +

+Definition at line 2041 of file form_elm.cpp. +

+References nlassert, and uint. +

+

02042 {
+02043   uint i;
+02044         for (i=0; i<Elements.size (); i++)
+02045         {
+02046                 if (Elements[i].Element == child)
+02047                 {
+02048                         Elements[i].Element = NULL;
+02049                         break;
+02050                 }
+02051         }
+02052 
+02053         // Element not found!
+02054         nlassert (i != Elements.size ());
+02055 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLGEORGES::CFormElm::warning bool  exception,
const char *  formName,
const char *  formFileName,
const char *  function,
const char *  format,
... 
[static, protected, inherited]
+
+ + + + + +
+   + + +

+ +

+Definition at line 1656 of file form_elm.cpp. +

+References buffer, format, and NLGEORGES::warning(). +

+Referenced by NLGEORGES::CFormElm::convertValue(), NLGEORGES::CFormElm::getArrayNode(), NLGEORGES::CFormElm::getArrayNodeName(), NLGEORGES::CFormElm::getArraySize(), NLGEORGES::CFormElm::getArrayValue(), NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElm::getStructNode(), NLGEORGES::CFormElm::getStructNodeName(), NLGEORGES::CFormElm::getStructSize(), NLGEORGES::CFormElm::getValue(), NLGEORGES::CFormElm::getValueByName(), NLGEORGES::CFormElm::setValueByName(), and NLGEORGES::CFormElm::warning(). +

+

01657 {
+01658         // Make a buffer string
+01659         va_list args;
+01660         va_start( args, format );
+01661         char buffer[1024];
+01662         vsnprintf( buffer, 1024, format, args );
+01663         va_end( args );
+01664 
+01665         // Set the warning
+01666         NLGEORGES::warning (exception, "(CFormElm::%s) on node (%s) in form (%s) : %s", function, formName, formFileName, buffer);
+01667 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NLGEORGES::CFormElmVirtualStruct::warning bool  exception,
const char *  function,
const char *  format,
... 
const [virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLGEORGES::CFormElmStruct. +

+Definition at line 2230 of file form_elm.cpp. +

+References buffer, format, NLGEORGES::CForm::getFilename(), NLGEORGES::CFormElmStruct::getFormName(), and NLGEORGES::warning(). +

+Referenced by read(). +

+

02231 {
+02232         // Make a buffer string
+02233         va_list args;
+02234         va_start( args, format );
+02235         char buffer[1024];
+02236         vsnprintf( buffer, 1024, format, args );
+02237         va_end( args );
+02238 
+02239         // Set the warning
+02240         string formName;
+02241         getFormName (formName, NULL);
+02242         NLGEORGES::warning (exception, "(CFormElmVirtualStruct::%s) on node (%s) in form (%s) : %s", function, formName.c_str (), Form->getFilename ().c_str (), buffer);
+02243 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
xmlNodePtr NLGEORGES::CFormElmVirtualStruct::write xmlNodePtr  node,
const CForm form,
const char *  structName,
bool  forceWrite = false
const [virtual]
+
+ + + + + +
+   + + +

+ +

+Reimplemented from NLGEORGES::CFormElmStruct. +

+Definition at line 2140 of file form_elm.cpp. +

+References DfnFilename, isUsed(), and uint. +

+

02141 {
+02142         // Is used ?
+02143         if (isUsed (form) || forceWrite)
+02144         {
+02145                 // *** Header
+02146                 xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"VSTRUCT", NULL);
+02147 
+02148                 // Write the DFN filename in the node
+02149                 xmlSetProp (node, (const xmlChar*)"DfnName", (const xmlChar*)DfnFilename.c_str());
+02150 
+02151                 // Element name
+02152                 if (structName != NULL)
+02153                 {
+02154                         // Struct name
+02155                         xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName);
+02156                 }
+02157 
+02158                 // For each elements of the structure
+02159                 uint elm;
+02160                 for (elm=0; elm<Elements.size(); elm++)
+02161                 {
+02162                         // Create a node if it exist
+02163                         if (Elements[elm].Element)
+02164                                 Elements[elm].Element->write (node, form, Elements[elm].Name.c_str());
+02165                 }
+02166 
+02167                 // Return the new node
+02168                 return node;
+02169         }
+02170         return NULL;
+02171 }
+
+


Field Documentation

+

+ + + + +
+ + +
std::string NLGEORGES::CFormElmVirtualStruct::DfnFilename +
+
+ + + + + +
+   + + +

+ +

+Definition at line 335 of file form_elm.h. +

+Referenced by getDfnName(), NLGEORGES::CFormElm::getIternalNodeByName(), read(), and write().

+

+ + + + +
+ + +
std::vector<CFormElmStructElm> NLGEORGES::CFormElmStruct::Elements [inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 318 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElm::getIternalNodeByName().

+

+ + + + +
+ + +
CForm* NLGEORGES::CFormElm::Form [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 231 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElm::arrayDeleteNodeByName(), NLGEORGES::CFormElm::arrayInsertNodeByName(), NLGEORGES::CFormElm::CFormElm(), NLGEORGES::CFormElm::createNodeByName(), NLGEORGES::CFormElm::deleteNodeByName(), NLGEORGES::CFormElm::getForm(), NLGEORGES::CFormElm::getNodeByName(), NLGEORGES::CFormElm::getValueByName(), and NLGEORGES::CFormElm::isUsed().

+

+ + + + +
+ + +
NLMISC::CSmartPtr<CFormDfn> NLGEORGES::CFormElmStruct::FormDfn [inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 277 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElmStruct::build(), NLGEORGES::CFormElmStruct::CFormElmStruct(), NLGEORGES::CFormElmStruct::getDependencies(), NLGEORGES::CFormElm::getIternalNodeByName(), NLGEORGES::CFormElmStruct::getStructDfn(), NLGEORGES::CForm::insertParent(), and NLGEORGES::CFormElmStruct::read().

+

+ + + + +
+ + +
const CFormDfn* NLGEORGES::CFormElm::ParentDfn [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 237 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElm::arrayDeleteNodeByName(), NLGEORGES::CFormElm::arrayInsertNodeByName(), NLGEORGES::CFormElm::CFormElm(), NLGEORGES::CFormElm::createNodeByName(), NLGEORGES::CFormElm::deleteNodeByName(), and NLGEORGES::CFormElm::getNodeByName().

+

+ + + + +
+ + +
uint NLGEORGES::CFormElm::ParentIndex [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 240 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElm::arrayDeleteNodeByName(), NLGEORGES::CFormElm::arrayInsertNodeByName(), NLGEORGES::CFormElm::CFormElm(), NLGEORGES::CFormElm::createNodeByName(), NLGEORGES::CFormElm::deleteNodeByName(), and NLGEORGES::CFormElm::getNodeByName().

+

+ + + + +
+ + +
CFormElm* NLGEORGES::CFormElm::ParentNode [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 234 of file form_elm.h. +

+Referenced by NLGEORGES::CFormElm::CFormElm(), and NLGEORGES::CFormElm::getParent().

+

+ + + + +
+ + +
uint32 NLGEORGES::CFormElm::Round [protected, inherited] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 243 of file form_elm.h.

+


The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 12:45:08 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1