Class

base_class = CClass(
    name="BaseClass",
    members=[
        CClass.Constructor(arguments=[CFunction.Argument('arg', Cuint32)], access=CClass.Access.public),
    ]
)

my_class = CClass(
    name="InheritingClass",
    inherit_from=CClass.Inherit(base_class, access=CClass.Access.public),
    members=[
        CClass.Using(base_class.constructor, access=CClass.Access.public,
                     doc=Doc("Constructor", "Reusing constructor from base class")),
        CClass.Method('my_method', arguments=[CFunction.Argument('hello', Cuint8)], access=CClass.Access.protected,
                      static=True, doc=Doc("My Method")),
        CClass.Attribute('u8My_attr', Cuint8, initial_value=3, access=CClass.Access.private, static=True,
                         constexpr=True, doc=Doc("My Attribute")),
        CClass.TypeMember(Cuint8.type('NewType'), access=CClass.Access.public,
                          doc=Doc("New Type", "Defining types inside classes is awesome")),
    ],
    doc=Doc("Class Example", "This class holds methods and attributes to represent objects")
)

print(my_class.declaration())

class InheritingClass;

print(my_class.definition())

/**
 * @brief Class Example
 * 
 * This class holds methods and attributes to represent objects
 */
class InheritingClass: public BaseClass
{
public:
	/**
	 * @brief Constructor
	 * 
	 * Reusing constructor from base class
	 */
	using BaseClass::BaseClass;

	/**
	 * @brief New Type
	 * 
	 * Defining types inside classes is awesome
	 */
	typedef uint8_t NewType;
protected:
	/**
	 * @brief My Method
	 * 
	 * @param hello 
	 */
	static void my_method(uint8_t hello);
private:
	/** @brief My Attribute */
	static constexpr uint8_t u8My_attr = 3;
};

style = Style()
style.class_members = Style.ClassMembers.inline_access_preserve_order
print(my_class.definition(style))

/**
 * @brief Class Example
 * 
 * This class holds methods and attributes to represent objects
 */
class InheritingClass: public BaseClass
{
	/**
	 * @brief Constructor
	 * 
	 * Reusing constructor from base class
	 */
	public: using BaseClass::BaseClass;

	/**
	 * @brief My Method
	 * 
	 * @param hello 
	 */
	protected: static void my_method(uint8_t hello);

	/** @brief My Attribute */
	private: static constexpr uint8_t u8My_attr = 3;

	/**
	 * @brief New Type
	 * 
	 * Defining types inside classes is awesome
	 */
	public: typedef uint8_t NewType;
};

print(my_class.all_members_definition().render())

static void InheritingClass::my_method(uint8_t hello)
{

};