Metadata-Version: 1.1
Name: CppHeaderParser
Version: 1.9
Summary: Parse C++ header files and generate a data structure representing the class
Home-page: http://sourceforge.net/projects/cppheaderparser/
Author: Jashua Cloutier
Author-email: jashuac@bellsouth.net
License: BSD
Description: Python package "CppHeaderParser"
        --------------------------------
        **Purpose:** Parse C++ header files and generate a data structure representing the class
        
        **Author:** Jashua Cloutier (jashuac@bellsouth.net)
        
        **Licence:** BSD
        
        **External modules required:** PLY
        
        **Quick start**::
        
            #include <vector>
            #include <string>
            using namespace std;
            class SampleClass
            {
            public:
                SampleClass();
                /*!
                 * Method 1
                 */
                string meth1();
            
                ///
                /// Method 2 description
                ///
                /// @param v1 Variable 1
                ///
                int meth2(int v1);
            
                /**
                 * Method 3 description
                 *
                 * \param v1 Variable 1
                 * \param v2 Variable 2
                 */
                void meth3(const string & v1, vector<string> & v2);
            
                /**********************************
                 * Method 4 description
                 *
                 * @return Return value
                 *********************************/
                unsigned int meth4();
            private:
                void * meth5(){return NULL};
            
                /// prop1 description
                string prop1;
                //! prop5 description
                int prop5;
            };
            namespace Alpha
            {
                class AlphaClass
                {
                public:
                    AlphaClass();
            
                    void alphaMethod();
            
                    string alphaString;
                };
            
                namespace Omega
                {
                    class OmegaClass
                    {
                    public:
                        OmegaClass();
            
                        string omegaString;
                    };
                };
            }
            
        
        **Python code**::
        
            #!/usr/bin/python
            import sys
            sys.path = ["../"] + sys.path
            import CppHeaderParser
            try:
                cppHeader = CppHeaderParser.CppHeader("SampleClass.h")
            except CppHeaderParser.CppParseError,  e:
                print e
                sys.exit(1)
            
            print "CppHeaderParser view of %s"%cppHeader
            
            sampleClass = cppHeader.classes["SampleClass"]
            print "Number of public methods %d"%(len(sampleClass["methods"]["public"]))
            print "Number of private properties %d"%(len(sampleClass["properties"]["private"]))
            meth3 = [m for m in sampleClass["methods"]["public"] if m["name"] == "meth3"][0] #get meth3
            meth3ParamTypes = [t["type"] for t in meth3["parameters"]] #get meth3s parameters
            print "Parameter Types for public method meth3 %s"%(meth3ParamTypes)
            
            print "\nReturn type for meth1:"
            print cppHeader.classes["SampleClass"]["methods"]["public"][1]["rtnType"]
            
            print "\nDoxygen for meth2:"
            print cppHeader.classes["SampleClass"]["methods"]["public"][2]["doxygen"]
            
            print "\nParameters for meth3:"
            print cppHeader.classes["SampleClass"]["methods"]["public"][3]["parameters"]
            
            print "\nDoxygen for meth4:"
            print cppHeader.classes["SampleClass"]["methods"]["public"][4]["doxygen"]
            
            print "\nReturn type for meth5:"
            print cppHeader.classes["SampleClass"]["methods"]["private"][0]["rtnType"]
            
            print "\nDoxygen type for prop1:"
            print cppHeader.classes["SampleClass"]["properties"]["private"][0]["doxygen"]
            
            print "\nType for prop5:"
            print cppHeader.classes["SampleClass"]["properties"]["private"][1]["type"]
            
            print "\nNamespace for AlphaClass is:"
            print cppHeader.classes["AlphaClass"]["namespace"]
            
            print "\nReturn type for alphaMethod is:"
            print cppHeader.classes["AlphaClass"]["methods"]["public"][0]["rtnType"]
            
            print "\nNamespace for OmegaClass is:"
            print cppHeader.classes["OmegaClass"]["namespace"]
            
            print "\nType for omegaString is:"
            print cppHeader.classes["AlphaClass"]["properties"]["public"][0]["type"]
        
        **Output**::
        
            CppHeaderParser view of class SampleClass
            Inherits: 
            {
            public
                // Method
                {'name': 'SampleClass', 'parameters': [], 'rtnType': 'void'}
                {'doxygen': '/*!\n* Method 1\n*/', 'name': 'meth1', 'parameters': [], 'rtnType': 'string'}
                {'doxygen': '///\n/// Method 2 description\n///\n/// @param v1 Variable 1\n///', 'name': 'meth2', 'parameters': [{'type': 'int', 'name': 'v1', 'desc': 'Variable 1'}], 'rtnType': 'int'}
                {'doxygen': '/**\n* Method 3 description\n*\n* \\param v1 Variable 1\n* \\param v2 Variable 2\n*/', 'name': 'meth3', 'parameters': [{'type': 'const string &', 'name': 'v1', 'desc': 'Variable 1'}, {'type': 'vector<string> &', 'name': 'v2', 'desc': 'Variable 2'}], 'rtnType': 'void'}
                {'doxygen': '/**********************************\n* Method 4 description\n*\n* @return Return value\n*********************************/', 'name': 'meth4', 'parameters': [], 'rtnType': 'unsigned int'}
            protected
            private
                // Properties
                {'doxygen': '/// prop1 description', 'type': 'string', 'name': 'prop1'}
                {'doxygen': '//! prop5 description', 'type': 'int', 'name': 'prop5'}
                // Method
                {'name': 'meth5', 'parameters': [], 'rtnType': 'void *'}
            }
            class Alpha::AlphaClass
            Inherits: 
            {
            public
                // Properties
                {'type': 'string', 'name': 'alphaString'}
                // Method
                {'name': 'AlphaClass', 'parameters': [], 'rtnType': 'void'}
                {'name': 'alphaMethod', 'parameters': [], 'rtnType': 'void'}
            protected
            private
            }
            class Alpha::Omega::OmegaClass
            Inherits: 
            {
            public
                // Properties
                {'type': 'string', 'name': 'omegaString'}
                // Method
                {'name': 'OmegaClass', 'parameters': [], 'rtnType': 'void'}
            protected
            private
            }
            
            Number of public methods 5
            Number of private properties 2
            Parameter Types for public method meth3 ['const string &', 'vector<string> &']
            
            Return type for meth1:
            string
            
            Doxygen for meth2:
            ///
            /// Method 2 description
            ///
            /// @param v1 Variable 1
            ///
            
            Parameters for meth3:
            [{'type': 'const string &', 'name': 'v1', 'desc': 'Variable 1'}, {'type': 'vector<string> &', 'name': 'v2', 'desc': 'Variable 2'}]
            
            Doxygen for meth4:
            /**********************************
            * Method 4 description
            *
            * @return Return value
            *********************************/
            
            Return type for meth5:
            void *
            
            Doxygen type for prop1:
            /// prop1 description
            
            Type for prop5:
            int
            
            Namespace for AlphaClass is:
            Alpha
            
            Return type for alphaMethod is:
            void
            
            Namespace for OmegaClass is:
            Alpha::Omega
            
            Type for omegaString is:
            string
            
        
        
        Contributors
        ------------
        Chris Love
Keywords: c++ header parser ply
Platform: Platform Independent
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: C++
Classifier: License :: OSI Approved :: BSD License
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development
Classifier: Topic :: Software Development :: Code Generators
Classifier: Topic :: Software Development :: Compilers
Classifier: Topic :: Software Development :: Disassemblers
Requires: ply
