{

public:

void parse(zval* zvp,int argno)

{

// NOTE: Parse assumes 'value' is empty.

parse_impl(zvp,argno);

}

void parse_with_context(zval* zvp,const char* ctx);

private:

virtual void parse_impl(zval* zvp,int argno) = 0;

public php_parameter

{

public:

php_output_parameter():

zvp(nullptr)

{

}

zval* get_value()

{

return zvp;

}

private:

zval* zvp;

virtual void parse_impl(zval* zvp,int argno);

public php_parameter

{

public:

php_value_base()

{

ZVAL_UNDEF(&value);

}

zval* get_value()

{

return &value;

}

void set_value(zval* zvp)

{

ZVAL_COPY_VALUE(&value,zvp);

}

bool is_null() const

{

return Z_TYPE(value) == IS_NULL;

}

protected:

zval value;

public php_value_base

{

private:

virtual void parse_impl(zval* zvp,int argno);

{

int result;

zend_long dummy;

result = zend_parse_parameter(ZEND_PARSE_PARAMS_THROW,argno,zvp,"l",&dummy);

if (result == FAILURE) {

throw php_git2_propagated_exception();

}

ZVAL_LONG(&value,dummy);

{

if (Z_TYPE(value) == IS_TRUE) {

RETURN_TRUE;

}

RETURN_FALSE;

{

int result;

zend_bool dummy;

result = zend_parse_parameter(ZEND_PARSE_PARAMS_THROW,argno,zvp,"b",&dummy);

if (result == FAILURE) {

throw php_git2_propagated_exception();

}

ZVAL_BOOL(&value,dummy);

{

int result;

double dummy;

result = zend_parse_parameter(ZEND_PARSE_PARAMS_THROW,argno,zvp,"d",&dummy);

if (result == FAILURE) {

throw php_git2_propagated_exception();

}

ZVAL_DOUBLE(&value,dummy);

{

// This will copy the string buffer (i.e. duplicate it).

RETVAL_STRING(Z_STRVAL(value));

{

int result;

zend_string* dummy;

result = zend_parse_parameter(ZEND_PARSE_PARAMS_THROW,argno,zvp,"S",&dummy);

if (result == FAILURE) {

throw php_git2_propagated_exception();

}

ZVAL_STR(&value,dummy);

virtual public php_string

{

public:

const char* byval_git2() const

{

if (is_null()) {

return nullptr;

}

return php_string::byval_git2();

}

protected:

virtual void parse_impl(zval* zvp,int argno)

{

if (Z_TYPE_P(zvp) == IS_NULL) {

ZVAL_NULL(&value);

return;

}

php_string::parse_impl(zvp,argno);

}

{

public:

php_string_ref():

ptr(nullptr)

{

}

const char** byval_git2()

{

return &ptr;

}

void ret(zval* return_value)

{

if (ptr != NULL) {

RETVAL_STRING(ptr);

return;

}

ZVAL_NULL(return_value);

}

private:

const char* ptr;

public php_output_parameter

{

public:

php_string_out():

ptr(nullptr)

{

}

~php_string_out()

{

if (ptr == nullptr) {

ZVAL_NULL(get_value());

}

else {

ZVAL_STRING(get_value(),ptr);

}

}

const char** byval_git2()

{

return &ptr;

}

private:

const char* ptr;

{

public:

using connect_t = StringType;

typedef IntType target_t;

php_string_length_connector(connect_t& obj):

conn(obj)

{

}

target_t byval_git2()

{

return static_cast<IntType>(Z_STRLEN_P(conn.get_value()));

}

protected:

connect_t& conn;

public php_string_length_connector<IntType,StringType>

{

using base_type = php_string_length_connector<IntType,StringType>;

public:

using typename base_type::connect_t;

using typename base_type::target_t;

php_string_length_connector_nullable(connect_t& obj):

base_type(obj)

{

}

target_t byval_git2()

{

zval* zvp = base_type::conn.get_value();

if (Z_TYPE_P(zvp) != IS_STRING) {

return 0;

}

return static_cast<IntType>(Z_STRLEN_P(zvp));

}

{

public:

using connect_t = php_long;

using target_t = char*;

php_string_buffer_connector(connect_t& obj)

{

bufsz = static_cast<size_t>(obj.byval_git2());

buffer = static_cast<char*>(emalloc(bufsz));

}

~php_string_buffer_connector()

{

efree(buffer);

}

target_t byval_git2()

{

return buffer;

}

void ret(zval* return_value)

{

RETVAL_STRINGL(buffer,bufsz);

}

private:

char* buffer;

size_t bufsz;

public php_long

{

public:

IntType byval_git2() const

{

return static_cast<IntType>(php_long::byval_git2());

}

{

public:

IntType* byval_git2()

{

return &n;

}

void ret(zval* return_value)

{

RETVAL_LONG(static_cast<zend_long>(n));

}

IntType get_value() const

{

return n;

}

private:

IntType n;

public php_long_ref<IntType>

{

public:

void ret(zval* return_value)

{

if (get_value()) {

RETURN_TRUE;

}

RETURN_FALSE;

}

protected:

using php_long_ref<IntType>::get_value;

public php_output_parameter

{

public:

~php_long_out()

{

ZVAL_LONG(get_value(),static_cast<zend_long>(n));

}

IntType* byval_git2()

{

return &n;

}

private:

IntType n;

public php_value_base

{

protected:

virtual void parse_impl(zval* zvp,int argno);

public php_resource_base

{

public:

typedef GitResource resource_t;

typename GitResource::git2_type byval_git2()

{

return get_object()->get_handle();

}

// This member function is used to retrieve the resource object. We must

// make sure it has been fetched from the resource value.

GitResource* get_object()

{

return reinterpret_cast<GitResource*>(Z_RES_VAL(value));

}

protected:

virtual void parse_impl(zval* zvp,int argno)

{

void* result;

php_resource_base::parse_impl(zvp,argno);

result = zend_fetch_resource(Z_RES(value),

GitResource::resource_name(),

GitResource::resource_le());

if (result == nullptr) {

throw php_git2_propagated_exception();

}

}

public php_resource<GitResource>

{

public:

typename GitResource::git2_type byval_git2()

{

GitResource* res = php_resource<GitResource>::get_object();

// Ensure that the resource owns the underlying handle before

// returning it.

if (!res->is_owner()) {

throw php_git2_exception(

"Cannot execute libgit2 call on non-owner resource");

}

return res->get_handle();

}

{

public:

php_resource_ref():

rsrc(nullptr)

{

}

typename GitResource::git2_type* byval_git2()

{

// Create a resource backing instance if it does not already exist.

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

}

return rsrc->get_handle_byref();

}

typename GitResource::const_git2_type* byval_git2() const

{

// Create a resource backing instance if it does not already exist.

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

}

// Cast the resource object to have the same kind of constness to

// force the compiler to call the correct overloaded member

// function. We have to do this since it's mutable.

return const_cast<const GitResource*>(rsrc)->get_handle_byref();

}

void ret(zval* return_value) const

{

zend_resource* zr;

zr = zend_register_resource(rsrc,GitResource::resource_le());

RETVAL_RES(zr);

}

GitResource* get_object() const

{

// Retrieve the resource object, creating it if it does not exist.

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

}

return rsrc;

}

void set_object(typename GitResource::git2_type obj)

{

// Create a resource backing instance if it does not already exist.

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

}

rsrc->set_handle(obj);

}

void set_object(typename GitResource::const_git2_type obj) const

{

// Create a resource backing instance if it does not already exist.

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

}

rsrc->set_handle(const_cast<typename GitResource::git2_type>(obj));

}

private:

mutable GitResource* rsrc;

{

public:

php_resource_nullable_ref():

rsrc(nullptr), handle(nullptr)

{

}

typename GitResource::git2_type*

byval_git2()

{

// Just return the handle. Delay creating the resource backing until

// later and after we know the return value is not NULL.

return &handle;

}

void ret(zval* return_value)

{

// If the handle was non-NULL, create a resource backing. Then pass

// it off to a new resource zval.

if (handle != nullptr) {

zend_resource* zr;

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

rsrc->set_handle(handle);

}

zr = zend_register_resource(rsrc,GitResource::resource_le());

RETVAL_RES(zr);

}

else {

RETVAL_NULL();

}

}

GitResource* get_object()

{

// Return the resource backing if the handle was non-NULL. Otherwise

// return NULL.

if (handle != nullptr) {

if (rsrc == nullptr) {

rsrc = php_git2_create_resource<GitResource>();

rsrc->set_handle(handle);

}

return rsrc;

}

return nullptr;

}

private:

GitResource* rsrc;

typename GitResource::git2_type handle;

public php_output_parameter,

public php_resource_ref<GitResource>

{

public:

~php_resource_ref_out()

{

php_resource_ref<GitResource>::ret(get_value());

}

public php_output_parameter,

public php_resource_nullable_ref<GitResource>

{

public:

~php_resource_nullable_ref_out()

{

php_resource_nullable_ref<GitResource>::ret(get_value());

}

public php_resource<GitResource>

{

using base = php_resource<GitResource>;

public:

typename GitResource::git2_type byval_git2()

{

// Resource may be null.

if (base::is_null()) {

return nullptr;

}

return base::byval_git2();

}

GitResource* get_object()

{

if (base::is_null()) {

return nullptr;

}

return base::get_object();

}

protected:

using base::value;

private:

virtual void parse_impl(zval* zvp,int argno)

{

if (Z_TYPE_P(zvp) == IS_NULL) {

ZVAL_NULL(&value);

return;

}

base::parse_impl(zvp,argno);

}

public php_resource<GitResource>

{

public:

typename GitResource::git2_type byval_git2()

{

// Delete the PHP resource. This will cause the resource to be

// invalidated across any zvals that reference it and the underlying

// handle will be destroyed (if it has no more references).

zend_list_close(Z_RES(value));

// The return value should not be used. We do not attempt frees

// directly from user space.

return nullptr;

}

protected:

using php_resource<GitResource>::value;

public php_resource<GitResource>

{

public:

~php_resource_cleanup_delayed()

{

// Delete the PHP resource. This will cause the resource to be

// invalidated across any zvals that reference it and the underlying

// handle will be destroyed (if it has no more references).

zend_list_close(Z_RES(value));

}

protected:

using php_resource<GitResource>::value;

{

public:

php_git_oid()

{

memset(&oid,0,sizeof(git_oid));

}

git_oid* byval_git2()

{

return &oid;

}

void ret(zval* return_value)

{

char buf[GIT_OID_HEXSZ + 1];

git_oid_tostr(buf,sizeof(buf),&oid);

RETVAL_STRING(buf);

}

private:

git_oid oid;

virtual public php_string

{

public:

git_oid* byval_git2()

{

// Convert PHP string to git_oid.

convert_oid_fromstr(&oid,Z_STRVAL(value),Z_STRLEN(value));

return &oid;

}

private:

git_oid oid;

public php_string_nullable,

public php_git_oid_fromstr

{

public:

git_oid* byval_git2()

{

if (Z_TYPE(value) == IS_STRING) {

return php_git_oid_fromstr::byval_git2();

}

return nullptr;

}

private:

git_oid oid;

using php_string_nullable::parse_impl;

public php_git_oid_fromstr

{

public:

git_oid byval_git2()

{

return *php_git_oid_fromstr::byval_git2();

}

public php_output_parameter,

public php_git_oid

{

public:

~php_git_oid_out()

{

ret(get_value());

}

{

public:

php_git_strarray()

{

memset(&arr,0,sizeof(git_strarray));

}

~php_git_strarray()

{

git_strarray_free(&arr);

}

git_strarray* byval_git2()

{

return &arr;

}

void ret(zval* return_value) const

{

// Convert the strarray to a PHP array.

array_init(return_value);

for (size_t i = 0;i < arr.count;++i) {

add_next_index_string(return_value,arr.strings[i]);

}

}

private:

git_strarray arr;

{

public:

php_git_oidarray()

{

memset(&arr,0,sizeof(git_oidarray));

}

~php_git_oidarray()

{

git_oidarray_free(&arr);

}

git_oidarray* byval_git2()

{

return &arr;

}

void ret(zval* return_value) const

{

array_init(return_value);

for (size_t i = 0;i < arr.count;++i) {

char buf[GIT_OID_HEXSZ + 1];

git_oid_tostr(buf,sizeof(buf),arr.ids + i);

add_next_index_string(return_value,buf);

}

}

private:

git_oidarray arr;

{

public:

php_git_buf()

{

memset(&buf,0,sizeof(git_buf));

}

~php_git_buf()

{

git_buf_free(&buf);

}

git_buf* byval_git2()

{

return &buf;

}

void ret(zval* return_value) const

{

// Convert the git_buf into a PHP string. Make sure to copy the

// buffer since the destructor will free the git_buf.

RETVAL_STRINGL(buf.ptr,buf.size);

}

private:

git_buf buf;

public php_output_parameter,

public php_git_buf

{

public:

~php_git_buf_out()

{

ret(get_value());

}

{

public:

char* byval_git2()

{

return buffer;

}

void ret(zval* return_value)