C++ IoObject_addMethodTable_函数代码示例

IoSkipDBM *IoSkipDBM_proto(void *state)
{
	IoMethodTable methodTable[] = {
	{"setPath",  IoSkipDBM_setPath},
	{"path",  IoSkipDBM_path},
	{"open",     IoSkipDBM_open},
	{"close",    IoSkipDBM_close},
	{"isOpen",   IoSkipDBM_isOpen},
	{"delete",   IoSkipDBM_delete},
	{"root",     IoSkipDBM_root},
	{"begin",     IoSkipDBM_beginTransaction},
	{"commit",     IoSkipDBM_commitnTransaction},
	//{"at",       IoSkipDBM_at},
	{"compact",  IoSkipDBM_compact},
	{NULL, NULL},
	};

	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoSkipDBM_newTag(state));

	IoObject_setDataPointer_(self, SkipDBM_new());
	IoState_registerProtoWithFunc_((IoState *)state, self, IoSkipDBM_proto);

	IoObject_addMethodTable_(self, methodTable);
	return self;
}

IoMap *IoMap_proto(void *state)
{
    IoMethodTable methodTable[] = {
        {"empty",    IoMap_empty},
        {"at",       IoMap_at},
        {"atPut",    IoMap_atPut},
        {"atIfAbsentPut", IoMap_atIfAbsentPut},
        {"size",     IoMap_size},
        {"keys",     IoMap_keys},
        {"values",   IoMap_values},
        {"foreach",  IoMap_foreach},
        {"hasKey",   IoMap_hasKey},
        {"hasValue", IoMap_hasValue},
        {"removeAt", IoMap_removeAt},
        {NULL, NULL},
    };

    IoObject *self = IoObject_new(state);

    IoObject_tag_(self, IoMap_newTag(state));
    IoObject_setDataPointer_(self, PHash_new());

    IoState_registerProtoWithFunc_((IoState *)state, self, IoMap_proto);

    IoObject_addMethodTable_(self, methodTable);
    return self;
}

IoYajlGen *IoYajlGen_proto(void *state)
{
	IoYajlGen *self = IoObject_new(state);
	IoObject_tag_(self, IoYajlGen_newTag(state));

	yajl_gen_config config = { 0, "" };
	IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL));

	IoState_registerProtoWithFunc_(state, self, IoYajlGen_proto);

	{
		IoMethodTable methodTable[] = 
		{
			{"pushNull", IoYajlGen_pushNull},
			{"pushString", IoYajlGen_pushString},
			{"pushInteger", IoYajlGen_pushInteger},
			{"pushDouble", IoYajlGen_pushDouble},
			{"pushNumberString", IoYajlGen_pushNumberString},
			{"pushBool", IoYajlGen_pushBool},
			{"openMap", IoYajlGen_openMap},
			{"closeMap", IoYajlGen_closeMap},
			{"openArray", IoYajlGen_openArray},
			{"closeArray", IoYajlGen_closeArray},
			{"generate", IoYajlGen_generate},
			{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
		
	return self;
}

IoODEJointGroup *IoODEJointGroup_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoODEJointGroup_newTag(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEJointGroupData)));

	JOINTGROUPID = 0;
	WORLD = 0L;
	DATA(self)->joints = 0L;

	IoState_registerProtoWithFunc_(state, self, IoODEJointGroup_proto);

	{
		IoMethodTable methodTable[] = {
		{"jointGroupId", IoODEJointGroup_jointGroupId},
		{"world", IoODEJointGroup_world},
		{"empty", IoODEJointGroup_empty},
		{"joints", IoODEJointGroup_joints},
		{"createContact", IoODEJointGroup_createContact},
		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}

IoCFFIPointer *IoCFFIPointer_proto(void *state)
{
	IoObject *self = IoCFFIDataType_new(state);
	IoObject_tag_(self, IoCFFIPointer_newTag(state));

	IoObject_setSlot_to_(self, IOSYMBOL("pointers"), IoMap_new(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(IoCFFIPointerData)));
	memset(DATA(self), 0, sizeof(IoCFFIPointerData));
	DATA(self)->valuePointer = &(DATA(self)->ptr);

	IoState_registerProtoWithFunc_(state, self, IoCFFIPointer_proto);

	{
		IoMethodTable methodTable[] = {
			{"address", IoCFFIPointer_address},
			{"asBuffer", IoCFFIPointer_asBuffer},
			{"at", IoCFFIPointer_at},
			{"atPut", IoCFFIPointer_atPut},
			{"castTo", IoCFFIPointer_castTo},
			{"value", IoCFFIPointer_value},
			{"setValue", IoCFFIPointer_setValue},
			{"toType", IoCFFIPointer_toType},
			{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}

	return self;
}

IoEvDNSRequest *IoEvDNSRequest_proto(void *state)
{
	IoObject *self = IoObject_new(state);

	IoObject_tag_(self, IoEvDNSRequest_newTag(state));
	IoObject_setDataPointer_(self, 0x0);

	IoState_registerProtoWithFunc_((IoState *)state, self, IoEvDNSRequest_proto);

	{
		IoMethodTable methodTable[] = {
		{"resolveIPv4", IoEvDNSRequest_resolveIPv4},
		/*
		{"resolveIPv6", IoEvDNSRequest_resolveIPv6},
		{"resolveReverseIPv4", IoEvDNSRequest_resolveReverseIPv4},
		{"resolveReverseIPv6", IoEvDNSRequest_resolveReverseIPv6},
		*/
		{NULL, NULL},
		};

		IoObject_addMethodTable_(self, methodTable);
	} 


	return self;
}

IoCairoSurfacePattern *IoCairoSurfacePattern_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoCairoSurfacePattern_newTag(state));

	IoState_registerProtoWithFunc_(state, self, IoCairoSurfacePattern_proto);

	IoCairoPattern_addMethods(self);
	{
		IoMethodTable methodTable[] = {
			{"create", IoCairoSurfacePattern_create},

			{"getSurface", IoCairoSurfacePattern_getSurface},

			{"setExtend", IoCairoSurfacePattern_setExtend},
			{"getExtend", IoCairoSurfacePattern_getExtend},

			{"setFilter", IoCairoSurfacePattern_setFilter},
			{"getFilter", IoCairoSurfacePattern_getFilter},

			{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}

IoCFFIArray *IoCFFIArray_proto(void *state)
{
	IoObject *self = IoCFFIDataType_new(state);
	IoObject_tag_(self, IoCFFIArray_newTag(state));

	IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoCFFIArrayData)));
	memset(DATA(self), 0, sizeof(IoCFFIArrayData));
	DATA(self)->needToFreeBuffer = 0;

	IoState_registerProtoWithFunc_(state, self, IoCFFIArray_proto);
	{
		IoMethodTable methodTable[] = {
			{"address", IoCFFIArray_address},
			{"asBuffer", IoCFFIArray_asBuffer},
			{"at", IoCFFIArray_at},
			{"atPut", IoCFFIArray_atPut},
			{"setValue", IoCFFIArray_setValue},
			{"size", IoCFFIArray_size},
			{"with", IoCFFIArray_with},
			{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}

	return self;
}

IoODEHinge *IoODEHinge_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoODEHinge_newTag(state));

	IoODEJoint_protoCommon(self);

	IoState_registerProtoWithId_(state, self, protoId);

	{
		IoMethodTable methodTable[] = {
				ODE_COMMON_JOINT_METHODS
#define PARAM(X, _N, _SETN) \
		{#_N, IoODEHinge_##_N}, \
		{#_SETN, IoODEHinge_##_SETN},
PARAMS
#undef PARAM

		{"anchor", IoODEHinge_anchor},
		{"setAnchor", IoODEHinge_setAnchor},
		{"anchor2", IoODEHinge_anchor2},
		{"axis", IoODEHinge_axis},
		{"setAxis", IoODEHinge_setAxis},
		{"angle", IoODEHinge_angle},
		{"angleRate", IoODEHinge_angleRate},
				{"addTorque", IoODEHinge_addTorque},

		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}

IoAsyncRequest *IoAsyncRequest_proto(void *state)
{
	IoAsyncRequest *self = IoObject_new(state);
	IoObject_tag_(self, IoAsyncRequest_newTag(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(struct aiocb)));

	IoState_registerProtoWithFunc_(state, self, IoAsyncRequest_proto);

	{
		IoMethodTable methodTable[] = {
		{"setDescriptor", IoAsyncRequest_setDescriptor},
		{"descriptor", IoAsyncRequest_descriptor},
		{"numberOfBytes", IoAsyncRequest_numberOfBytes},
		{"read", IoAsyncRequest_read},
		{"write", IoAsyncRequest_write},
		{"isDone", IoAsyncRequest_isDone},
		{"error", IoAsyncRequest_error},
		{"cancel", IoAsyncRequest_cancel},
		{"sync", IoAsyncRequest_sync},
		{"copyBufferTo", IoAsyncRequest_copyBufferTo},
		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}

	return self;
}

IoMP3Decoder *IoMP3Decoder_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoMP3Decoder_newTag(state));
	
	IoObject_setDataPointer_(self, calloc(1, sizeof(IoMP3DecoderData)));
	
	//DATA(self)->outSound = 0x0;
	DATA(self)->willProcessMessage = IoMessage_newWithName_label_(state, IOSYMBOL("willProcess"), IOSYMBOL("[MP3Decoder]"));
	DATA(self)->didProcessMessage = IoMessage_newWithName_label_(state, IOSYMBOL("didProcess"), IOSYMBOL("[MP3Decoder]"));
	DATA(self)->inputBuffer  = IoSeq_new(state);
	DATA(self)->outputBuffer = IoSeq_new(state);
	DATA(self)->tmpInputBa = UArray_new();
	
	IoState_registerProtoWithFunc_(state, self, IoMP3Decoder_proto);
	
	{
		IoMethodTable methodTable[] = {
		{"start", IoMP3Decoder_start},
		{"stop",  IoMP3Decoder_stop},
		{"inputBuffer",  IoMP3Decoder_inputBuffer},
		{"outputBuffer",  IoMP3Decoder_outputBuffer},
		
		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}

IoODEBox *IoODEBox_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoODEBox_newTag(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(IoODEBoxData)));

	GEOMID = 0;

	IoState_registerProtoWithId_(state, self, protoId);

	{
		IoMethodTable methodTable[] = {
		{"geomId", IoODEBox_geomId},
		{"lengths", IoODEBox_lengths},
		{"setLengths", IoODEBox_setLengths},
		{"pointDepth", IoODEBox_pointDepth},
		{"body", IoODEBox_body},
		{"setBody", IoODEBox_setBody},
		{"collide", IoODEGeom_collide},

		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}

// _proto creates the first-ever instance of the prototype 
IoObject *IoCInvokeStructureInstance_proto(void *state)
{
        // First we allocate a new IoObject
        IoCInvokeStructureInstance *self = IoObject_new(state);

        // Then tag it
        IoObject_tag_(self, IoCInvokeStructureInstance_newTag(state));
	    IoObject_setDataPointer_(self, calloc(1, sizeof(IoCInvokeStructureInstanceData)));
        
	    // then register this proto generator
        IoState_registerProtoWithFunc_(state, self, IoCInvokeStructureInstance_proto);

        // and finally, define the table of methods this proto supports
        // we just have one method here, returnSelf, then terminate the array
        // with NULLs
        {
                IoMethodTable methodTable[] = {
			        {"setValue", IoCInvokeStructureInstance_setValue},
			        {"setLibrary", IoCInvokeStructureInstance_setLibrary},
                    {"getValue", IoCInvokeStructureInstance_getValue},
                	{NULL, NULL},
                };
                IoObject_addMethodTable_(self, methodTable);
        }

        return self;
}

IoObject *IoMemcached_proto(void *state)
{
	IoMemcached *self = IoObject_new(state);
	IoObject_tag_(self, IoMemcached_newTag(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(IoMemcachedData)));

	IoState_registerProtoWithFunc_(state, self, IoMemcached_proto);

	{
		IoMethodTable methodTable[] = {
		{"addServer",  IoMemcached_addServer},
		{"set",        IoMemcached_set},
		{"add",        IoMemcached_add},
		{"replace",    IoMemcached_replace},
		{"append",     IoMemcached_append},
		{"prepend",    IoMemcached_prepend},
		{"get",        IoMemcached_get},
		{"getMulti",   IoMemcached_getMulti},
		{"delete",     IoMemcached_delete},
		{"flushAll",   IoMemcached_flushAll},
		{"incr",       IoMemcached_incr},
		{"decr",       IoMemcached_decr},
		{"stats",      IoMemcached_stats},
		{NULL, NULL},
		};
		IoObject_addMethodTable_(self, methodTable);
	}

	return self;
}

IoMP3Encoder *IoMP3Encoder_proto(void *state)
{
    IoObject *self = IoObject_new(state);
    IoObject_tag_(self, IoMP3Encoder_newTag(state));
    
    self->data = calloc(1, sizeof(IoMP3EncoderData));
    DATA(self)->outBuffer = IoBuffer_new(state);
    DATA(self)->encoder = MP3Encoder_new();
    MP3Encoder_setExternalOutputUArray_(DATA(self)->encoder, 
					   IoBuffer_rawUArray(DATA(self)->outBuffer));
    
    
    IoState_registerProtoWithFunc_(state, self, IoMP3Encoder_proto);
    
    {
	IoMethodTable methodTable[] = {
	{"encode", IoMP3Encoder_encode},
	{"end",  IoMP3Encoder_end},
	{"outBuffer",  IoMP3Encoder_outBuffer},
	{"setBitRate",  IoMP3Encoder_setBitRate},
	{"setSampleRate",  IoMP3Encoder_setSampleRate},
	{"setQuality",  IoMP3Encoder_setQuality},
	{"setCompressionRatio",  IoMP3Encoder_setCompressionRatio},
	{NULL, NULL},
	};
	IoObject_addMethodTable_(self, methodTable);
    }
    
    return self;
}