daeElement.h

Go to the documentation of this file.

/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/ 

#ifndef __DAE_ELEMENT_H__
#define __DAE_ELEMENT_H__
#include <string>
#include <dae/daeTypes.h>
#include <dae/daeMemorySystem.h>
#include <wchar.h>
#include <dae/daeArray.h>
#include <dae/daeRefCountedObj.h>
#include <dae/daeSmartRef.h>

//#ifndef NO_MALLOC_HEADER
//#include <malloc.h>
//#endif

namespace COLLADA_TYPE
{
        typedef int TypeEnum;
}

class DAE;
class daeMetaElement;
class daeMetaAttribute;
class daeDocument;
class daeURI;

class DLLSPEC daeElement : public daeRefCountedObj
{
public:
        DAE_ALLOC
protected:
        daeElement* _parent;
        daeDocument* _document;
        daeMetaElement* _meta;
        daeString _elementName;
        daeBoolArray _validAttributeArray; // This is now obsolete and can be removed
        void* _userData;

protected:
        daeElement( const daeElement &cpy ) : daeRefCountedObj() { (void)cpy; };
        virtual daeElement &operator=( const daeElement &cpy ) { (void)cpy; return *this; }

        void init();

        // These functions are called internally.
        void setDocument( daeDocument* c, bool notifyDocument );
        daeElement* simpleAdd(daeString name, int index = -1);

public:
        daeElement();
        daeElement(DAE& dae);

        virtual ~daeElement();

        void setup(daeMetaElement* meta);

        // These functions are for adding child elements. They return null if adding
        // the element failed.
        daeElement* add(daeString name, int index = -1);
        daeElement* add(daeElement* elt, int index = -1);
        daeElement* addBefore(daeElement* elt, daeElement* index);
        daeElement* addAfter(daeElement* elt, daeElement* index);

        // These functions are deprecated. Use 'add' instead.
        daeElement* createAndPlace(daeString elementName);
        daeElement* createAndPlaceAt(daeInt index, daeString elementName);
        daeBool placeElement(daeElement* element);
        daeBool placeElementAt(daeInt index, daeElement* element);
        daeBool placeElementBefore( daeElement* marker, daeElement *element );
        daeBool placeElementAfter( daeElement* marker, daeElement *element );

        daeInt findLastIndexOf( daeString elementName );

        daeBool removeChildElement(daeElement* element);
        
        static daeBool removeFromParent(daeElement* element)
        {
                if(element != NULL && element->_parent != NULL) 
                        return(element->_parent->removeChildElement(element));
                return false;
        };

        size_t getAttributeCount();
        
        daeMetaAttribute* getAttributeObject(daeString name);

        daeMetaAttribute* getAttributeObject(size_t i);

        std::string getAttributeName(size_t i);

        daeBool hasAttribute(daeString name);

        daeBool isAttributeSet(daeString name);

        std::string getAttribute(daeString name);

        void getAttribute(daeString name, std::string& value);

        std::string getAttribute(size_t i);

        void getAttribute(size_t i, std::string& value);

        struct DLLSPEC attr {
                attr();
                attr(const std::string& name, const std::string& value);

                std::string name;
                std::string value;
        };
        
        daeTArray<attr> getAttributes();

        void getAttributes(daeTArray<attr>& attrs);

        virtual daeBool setAttribute(daeString name, daeString value);

        virtual daeBool setAttribute(size_t i, daeString value);

        daeMetaAttribute* getCharDataObject();

        daeBool hasCharData();

        std::string getCharData();

        void getCharData(std::string& data);

        daeBool setCharData(const std::string& data);

        // These functions are deprecated.
        daeMemoryRef getAttributeValue(daeString name); // Use getAttribute or getAttributeObject instead.
        daeBool hasValue(); // Use hasCharData instead.
        daeMemoryRef getValuePointer(); // Use getCharData or getCharDataObject instead.

        daeDocument* getDocument() const { return _document; }

        daeDocument* getCollection() const { return _document; }

        DAE* getDAE();
        
        void setDocument(daeDocument* c) { setDocument( c, true ); }
        void setCollection(daeDocument* c );

        daeURI* getDocumentURI() const;

        daeSmartRef<daeElement> createElement(daeString elementName);

        daeElement* getParentElement() { return _parent;}
        daeElement* getXMLParentElement() { return _parent;}
        void setParentElement( daeElement *parent ) { _parent = parent; }

        // These are helper structures to let the xml hierarchy search functions know when we've
        // found a match. You can implement a custom matcher by inheriting from this structure,
        // just like matchName and matchType.
        struct DLLSPEC matchElement {
                virtual bool operator()(daeElement* elt) const = 0;
                virtual ~matchElement() { };
        };

        // Matches an element by name
        struct DLLSPEC matchName : public matchElement {
                matchName(daeString name);
                virtual bool operator()(daeElement* elt) const;
                std::string name;
        };

        // Matches an element by schema type
        struct DLLSPEC matchType : public matchElement {
                matchType(daeInt typeID);
                virtual bool operator()(daeElement* elt) const;
                daeInt typeID;
        };

        // Returns a matching child element. By "child", I mean one hierarchy level beneath the
        // current element. This function is basically the same as getDescendant, except that it
        // only goes one level deep.
        daeElement* getChild(const matchElement& matcher);

        // Performs a breadth-first search and returns a matching descendant element. A "descendant
        // element" is an element beneath the current element in the xml hierarchy.
        daeElement* getDescendant(const matchElement& matcher);

        // Returns the parent element.
        daeElement* getParent();

        // Searches up through the xml hiearchy and returns a matching element.
        daeElement* getAncestor(const matchElement& matcher);

        // These functions perform the same as the functions above, except that they take the element
        // name to match as a string. This makes these functions a little simpler to use if you're
        // matching based on element name, which is assumed to be the most common case. Instead of
        // "getChild(matchName(eltName))", you can just write "getChild(eltName)".
        daeElement* getChild(daeString eltName);
        daeElement* getDescendant(daeString eltName);
        daeElement* getAncestor(daeString eltName);

        inline daeMetaElement* getMeta() { return _meta; }

        // These functions are deprecated. Use typeID instead.
        virtual COLLADA_TYPE::TypeEnum getElementType() const { return (COLLADA_TYPE::TypeEnum)0; }
        daeString getTypeName() const;

        virtual daeInt typeID() const = 0;

        daeString getElementName() const;
        void setElementName( daeString nm );
        
        daeString getID() const;

        daeTArray< daeSmartRef<daeElement> > getChildren();

        //void getChildren( daeElementRefArray &array );
        void getChildren( daeTArray<daeSmartRef<daeElement> > &array );

        template<typename T>
        daeTArray< daeSmartRef<T> > getChildrenByType() {
                daeTArray< daeSmartRef<T> > result;
                getChildrenByType(result);
                return result;
        }

        template<typename T>
        void getChildrenByType(daeTArray< daeSmartRef<T> >& matchingChildren) {
                matchingChildren.setCount(0);
                daeTArray< daeSmartRef<daeElement> > children;
                getChildren(children);
                for (size_t i = 0; i < children.getCount(); i++)
                        if (children[i]->typeID() == T::ID())
                                matchingChildren.append((T*)children[i].cast());
        }

        daeSmartRef<daeElement> clone( daeString idSuffix = NULL, daeString nameSuffix = NULL );

        // Class for reporting info about element comparisons
        struct DLLSPEC compareResult {
                int compareValue; // > 0 if elt1 > elt2,
                                  // < 0 if elt1 < elt2,
                                  // = 0 if elt1 = elt2
                daeElement* elt1;
                daeElement* elt2;
                bool nameMismatch; // true if the names didn't match
                std::string attrMismatch; // The name of the mismatched attribute, or "" if there was no attr mismatch
                bool charDataMismatch; // true if the char data didn't match
                bool childCountMismatch; // true if the number of children didn't match

                compareResult();
                std::string format(); // Write to a string
        };

        // Function for doing a generic, recursive comparison of two xml elements. It
        // also provides a full element ordering, so that you could store elements in
        // a map or a set. Return val is > 0 if elt1 > elt2, < 0 if elt1 < elt2, and 0
        // if elt1 == elt2.
        static int compare(daeElement& elt1, daeElement& elt2);

        // Same as the previous function, but returns a full compareResult object.
        static compareResult compareWithFullResult(daeElement& elt1, daeElement& elt2);

        void setUserData(void* data);

        void* getUserData();
        
public:
        // This function is called internally
        static void deleteCMDataArray(daeTArray<daeCharArray*>& cmData);
};

#include <dae/daeSmartRef.h>
typedef daeSmartRef<daeElement> daeElementRef;
typedef daeSmartRef<const daeElement> daeElementConstRef;
//#include <dae/daeArray.h>
typedef daeTArray<daeElementRef> daeElementRefArray;

#endif //__DAE_ELEMENT_H__

---

colladadom
Author(s): Du Hung Hou, Khronos.org, Marcus Barnes, Greg Corson, Herbert Law, Sebastian Schwarz, Steven Thomas, John Hsu (ros package), Tim Field (ros package)
autogenerated on Fri Jan 11 09:24:25 2013