pub fn parser_method<T: RegisteredClass>(
        &mut self,
    ) -> (ArgParser<'_, '_>, Option<&mut ZendClassObject<T>>) {
        let (parser, obj) = self.parser_object();
        (
            parser,
            obj.and_then(|obj| ZendClassObject::from_zend_obj_mut(obj)),
        )
    }
Returns an [`ArgParser`] pre-loaded with the arguments contained inside
`self`.

A reference to `$this` is also returned in an [`Option`], which resolves
to [`None`] if this function is not called inside a method.

This function differs from [`parse_object`] in the fact that it returns
a reference to a [`ZendClassObject`], which is an object that
contains an arbitrary Rust type at the start of the object. The
object will also resolve to [`None`] if the function is called
inside a method that does not belong to an object with type `T`.

# Example

```no_run
use ext_php_rs::{types::Zval, zend::ExecuteData, args::Arg, flags::DataType, prelude::*};

#[php_class]
#[derive(Debug)]
struct Example;

#[no_mangle]
pub extern "C" fn example_fn(ex: &mut ExecuteData, retval: &mut Zval) {
let mut a = Arg::new("a", DataType::Long);

let (parser, this) = ex.parser_method::<Example>();
let parser = parser
.arg(&mut a)
.parse();

if parser.is_err() {
return;
}

dbg!(a, this);
}

#[php_module]
pub fn module(module: ModuleBuilder) -> ModuleBuilder {
module
}
```

[`parse_object`]: #method.parse_object
src/zend/ex.rs