C++ class_register函数代码示例

static int init_uio_class(void)
{
	int ret;

	/* This is the first time in here, set everything up properly */
	ret = uio_major_init();
	if (ret)
		goto exit;

	ret = class_register(&uio_class);
	if (ret) {
		printk(KERN_ERR "class_register failed for uio\n");
		goto err_class_register;
	}
	return 0;

err_class_register:
	uio_major_cleanup();
exit:
	return ret;
}

int main(void) {
	resonators_class = class_new("basicresonators~", (method) resonators_new,
				     (method) resonators_free, (short)sizeof(t_resonators),
				     0L, A_GIMME, 0);

	post("Copyright (c) 1986, 1987-2013 Adrian Freed. All Rights Reserved");
	post("Maximum number of resonances: %d", MAXRESONANCES);
    
	class_addmethod(resonators_class, (method)resonators_dsp, "dsp", A_CANT, 0);
	class_addmethod(resonators_class, (method)resonators_dsp64, "dsp64", A_CANT, 0);
	class_addmethod(resonators_class, (method)resonators_list, "list", A_GIMME, 0);
	class_addmethod(resonators_class, (method)resonators_clear, "clear", 0);
	class_addmethod(resonators_class, (method)resonators_bang, "bang", 0);
	class_addmethod(resonators_class, (method)resonators_float, "float", A_FLOAT, 0);
	class_addmethod(resonators_class, (method)resonators_int, "int", A_LONG, 0);
	class_addmethod(resonators_class, (method)resonators_assist, "assist", A_CANT, 0);
	class_dspinit(resonators_class);
	class_register(CLASS_BOX, resonators_class);
    
	return 0;
}

int C74_EXPORT main()
{
	this_class = class_new("dynamic.out~",
						   (method) dynamic_out_new, 
						   (method)dynamic_out_free, 
						   sizeof(t_dynamic_out), 
						   NULL, 
						   A_DEFLONG, 
						   0);
    
	class_addmethod(this_class, (method)dynamic_out_dsp, "dsp", A_CANT, 0);
	class_addmethod(this_class, (method)dynamic_out_dsp64, "dsp64", A_CANT, 0);
    class_addmethod(this_class, (method)dynamic_out_assist, "assist", A_CANT, 0);
	class_addmethod(this_class, (method)dynamic_out_int, "int", A_LONG, 0);
    
	class_dspinit(this_class);
	
	class_register(CLASS_BOX, this_class);
	
	return 0;
}

static int init_exm_class(void)
{
	int ret;

	/* This is the first time in here, set everything up properly */
	ret = exm_major_init();
	if (ret)
		goto exit;

	ret = class_register(&exm_class);
	if (ret) {
		pr_err("class_register failed for exm\n");
		goto err_class_register;
	}
	return 0;

err_class_register:
	exm_major_cleanup();
exit:
	return ret;
}

void init_subt_ttx_ctrl(subt_ttx_ctrl_init_t *p_param)
{
    subt_ttx_ctrl_priv_t *p_this = NULL;
    RET_CODE ret = SUCCESS;
    
    p_this = mtos_malloc(sizeof(subt_ttx_ctrl_priv_t));
    
    memset(p_this, 0, sizeof(subt_ttx_ctrl_priv_t));
    p_this->mutex_lock_mode = p_param->lock_mode;
    p_this->enable_ttx_type_subt = p_param->enable_ttx_type_subt;
    p_this->subt_ready_cb = p_param->subt_ready_cb;
    p_this->ttx_ready_cb = p_param->ttx_ready_cb;
    class_register(SUBT_TTX_CTRL_CLASS_ID, (class_handle_t)p_this);


    ret = mul_teletext_init(&p_param->ttx_para); 
    CHECK_FAIL_RET_VOID(ret == SUCCESS);

    ret = mul_subtitle_init(&p_param->subt_para); 
    CHECK_FAIL_RET_VOID(ret == SUCCESS);    
}

int main (void)
{  
	t_class *c = class_new(OMAX_DOC_NAME, (method) oudp_new,(method) myobject_free,(short)sizeof(t_oudpreceive),0L,A_GIMME, 0);
  
	class_addmethod(c, (method)oudp_assist, "assist", A_CANT,0);
	class_addmethod(c, (method)odot_version, "version", 0);
	class_addmethod(c, (method)oudp_doc, "doc", 0);

	class_addmethod(c, (method)slipbyte, "int", A_LONG, 0);
	class_addmethod(c, (method)sliplist, "list", A_GIMME, 0);
  
	class_addmethod(c, (method)oudp_printcontents, "printcontents", 0);

	finder_addclass("Devices","slipOSC");

	class_register(CLASS_BOX, c);
	oudp_class = c;

	ODOT_PRINT_VERSION;
	return 0;
}

int C74_EXPORT main(void)
{
	t_class *max_class, *jit_class;
	
	jit_realsense_grab_init();	

	max_class = class_new("jit.realsense.grab", (method)max_jit_realsense_grab_new, (method)max_jit_realsense_grab_free, sizeof(t_max_jit_realsense_grab), NULL, A_GIMME, 0);
	max_jit_class_obex_setup(max_class, calcoffset(t_max_jit_realsense_grab, obex));

	jit_class = jit_class_findbyname(gensym("jit_realsense_grab"));
	max_jit_class_mop_wrap(max_class, jit_class, MAX_JIT_MOP_FLAGS_OWN_OUTPUTMATRIX | MAX_JIT_MOP_FLAGS_OWN_JIT_MATRIX);			// attrs & methods for name, type, dim, planecount, bang, outputmatrix, etc
	max_jit_class_wrap_standard(max_class, jit_class, 0);		// attrs & methods for getattributes, dumpout, maxjitclassaddmethods, etc

	max_jit_class_addmethod_usurp_low(max_class, (method)max_jit_realsense_grab_outputmatrix, "outputmatrix");

	class_addmethod(max_class, (method)max_jit_mop_assist, "assist", A_CANT, 0);	// standard matrix-operator (mop) assist fn

	class_register(CLASS_BOX, max_class);
	max_jit_realsense_grab_class = max_class;
	return 0;
}

int C74_EXPORT main(void)
{
	t_class *c;
	
	TTGraphInit();	
	common_symbols_init();
	
	c = class_new("j.unpack-", (method)UnpackNew, (method)UnpackFree, sizeof(Unpack), (method)0L, A_GIMME, 0);
	
	class_addmethod(c, (method)MaxGraphReset,		"graph.reset",		A_CANT, 0);
	class_addmethod(c, (method)MaxGraphConnect,		"graph.connect",	A_OBJ, A_LONG, 0);
	class_addmethod(c, (method)MaxGraphDrop,		"graph.drop",		A_CANT, 0);
 	class_addmethod(c, (method)MaxGraphObject,		"graph.object",		A_CANT, 0);

	class_addmethod(c, (method)UnpackAssist,		"assist",			A_CANT, 0); 
    class_addmethod(c, (method)object_obex_dumpout,	"dumpout",			A_CANT, 0);  
	
	class_register(_sym_box, c);
	sUnpackClass = c;
	return 0;
}

int main(void){
	t_class *c = class_new("te_breakout~", (method)bkout_new, (method)dsp_free, sizeof(t_bkout), 0L, A_GIMME, 0);
    
	class_dspinit(c);

	class_addmethod(c, (method)bkout_dsp, "dsp", A_CANT, 0);
	class_addmethod(c, (method)bkout_dsp64, "dsp64", A_CANT, 0);
	class_addmethod(c, (method)bkout_notify, "notify", A_CANT, 0);
	class_addmethod(c, (method)bkout_assist, "assist", A_CANT, 0);
    
	CLASS_ATTR_SYM(c, "name", 0, t_bkout, name);
	CLASS_ATTR_LONG(c, "function", 0, t_bkout, function);
	CLASS_ATTR_LONG(c, "numoutlets", 0, t_bkout, numoutlets);

	class_register(CLASS_BOX, c);
	bkout_class = c;

	common_symbols_init();

	return 0;
}

int main()
{
	t_class *c;

	c = class_new("match", (method)match_new, (method)match_free, 
		(short)sizeof(t_match), 0L, A_GIMME, 0);
	class_addmethod(c, (method)match_int, "int", A_LONG, 0);
	class_addmethod(c, (method)match_float, "float", A_FLOAT, 0);
	class_addmethod(c, (method)match_list,		"list",		A_GIMME, 0);
	class_addmethod(c, (method)match_anything,	"anything",	A_GIMME, 0);
	class_addmethod(c, (method)match_set,		"set",		A_GIMME,0);					
	class_addmethod(c, (method)match_clear,	"clear", 	0);
	class_addmethod(c, (method)match_assist,	"assist",A_CANT,0);
	class_register(CLASS_BOX, c);
	match_class = c;
	
	ps_nn = gensym("nn");
	ps_list = gensym("list");

	return 0;
}

void scripto_ui_classinit(void)
{
	t_class *c = class_new("scripto_ui", (method)scripto_ui_new, (method)scripto_ui_free, sizeof(t_scripto_ui), 0L, A_GIMME, 0L);

	c->c_flags |= CLASS_FLAG_NEWDICTIONARY;

	jbox_initclass(c, 0);
	class_addmethod(c, (method)scripto_ui_paint,	"paint",		A_CANT, 0);
	class_addmethod(c, (method)scripto_ui_mousedown,"mousedown",	A_CANT, 0);
	class_addmethod(c, (method)scripto_ui_mousedrag,"mousedrag",	A_CANT, 0);
	class_addmethod(c, (method)jbox_notify,			"notify",	A_CANT, 0);		// for auto-repainting

	CLASS_ATTR_RGBA(c, "oncolor", 0, t_scripto_ui, u_oncolor);
	CLASS_ATTR_PAINT(c, "oncolor", 0);
	CLASS_ATTR_RGBA(c, "offcolor", 0, t_scripto_ui, u_offcolor);
	CLASS_ATTR_PAINT(c, "offcolor", 0);

	class_register(CLASS_BOX, c);

	s_scripto_ui_class = c;
}

int C74_EXPORT main(void)
{	
	t_class *c;
	
	c = class_new("breakgen", (method)breakgen_new, (method)breakgen_free, (long)sizeof(t_breakgen), 
				  0L /* leave NULL!! */, A_GIMME, 0);
	
    class_addmethod(c, (method)breakgen_bang,			"bang", 0);
    class_addmethod(c, (method)breakgen_identify,		"identify", 0);
	CLASS_METHOD_ATTR_PARSE(c, "identify", "undocumented", gensym("long"), 0, "1");

	// here's an otherwise undocumented method, which does something that the user can't actually 
	// do from the patcher however, we want them to know about it for some weird documentation reason. 
	// so let's make it documentable. it won't appear in the quickref, because we can't send it from a message.
	class_addmethod(c, (method)breakgen_acant,			"blooop",       A_CANT, 0);
	CLASS_METHOD_ATTR_PARSE(c, "blooop", "documentable", gensym("long"), 0, "1");
    
    class_addmethod(c, (method)breakgen_wavetype,		"wavetype",     A_LONG, 0);
    class_addmethod(c, (method)breakgen_setfreq,		"freq",         A_FLOAT, 0);
    class_addmethod(c, (method)breakgen_setconstsig,	"constval",     A_FLOAT, 0);
    class_addmethod(c, (method)breakgen_setsr,          "sr",           A_FLOAT, 0);
    
    class_addmethod(c, (method)breakgen_setter,          "set",         A_GIMME, 0);
    class_addmethod(c, (method)breakgen_writebuf,        "writebuf",    A_GIMME, 0);
    class_addmethod(c, (method)breakgen_writefile,       "writefile",   A_GIMME, 0);

	/* you CAN'T call this from the patcher */
    class_addmethod(c, (method)breakgen_assist,			"assist",		A_CANT, 0);  
    class_addmethod(c, (method)breakgen_dblclick,		"dblclick",		A_CANT, 0);
    class_addmethod(c, (method)breakgen_getrand,		"getrand",		A_CANT, 0);
	
	CLASS_ATTR_SYM(c, "name", 0, t_breakgen, name);
	
	class_register(CLASS_BOX, c);
	breakgen_class = c;
    
    buffy_modified = gensym("buffer_modified");

	return 0;
}

int main(void) {
    
    t_class *c = class_new("radialbeameq~", (method)radialBeamformNew, (method)radialBeamformFree, sizeof(RadialBeamform), 0L, A_GIMME, 0);
    
    class_dspinit(c);
    
    version(0);
    
    CLASS_ATTR_LONG(c, "n", 0, RadialBeamform, sh_degree);
    CLASS_ATTR_FILTER_MIN(c, "n", 0);
    CLASS_ATTR_ACCESSORS(c, "n", 0, radialBeamformSetn);
    
    // needs special set get
    CLASS_ATTR_SYM(c, "mode", 0, RadialBeamform, bf_mode_sym);
    CLASS_ATTR_ACCESSORS(c, "mode", 0, radialBeamformSetMode);

    CLASS_ATTR_FLOAT(c, "max_wng", 0, RadialBeamform, max_wng);
    CLASS_ATTR_FILTER_MIN(c, "max_wng", 0);
    CLASS_ATTR_FILTER_MAX(c, "max_wng", 96);
    CLASS_ATTR_ACCESSORS(c, "max_wng", 0, radialBeamformSetWNG);
    
    CLASS_ATTR_FLOAT(c, "omega_cutoff", 0, RadialBeamform, omega_cutoff);
    CLASS_ATTR_FLOAT(c, "slope_cutoff", 0, RadialBeamform, slope_cutoff);

    CLASS_ATTR_FLOAT(c, "delta_n", 0, RadialBeamform, delta_n);
    CLASS_ATTR_ACCESSORS(c, "delta_n", 0, radialBeamformSetDeltan);
    CLASS_ATTR_FLOAT(c, "delta_n0", 0, RadialBeamform, delta_n0);
    CLASS_ATTR_ACCESSORS(c, "delta_n0", 0, radialBeamformSetDeltan);
    
    class_addmethod(c, (method)radialBeamformDsp, "dsp", A_CANT, 0);
	class_addmethod(c, (method)radialBeamformReset, "reset", 0);
    
	class_register(CLASS_BOX, c);
	radialbeameq_class = c;
    
	//common_symbols_init();
    
	return 0;
    
}

int main (void)
{
    this_class = class_new ("irextract~",
							(method) irextract_new, 
							(method)irextract_free, 
							sizeof(t_irextract), 
							0L,
							A_GIMME,
							0);
	
	class_addmethod (this_class, (method)irextract_assist, "assist", A_CANT, 0L);
	
	class_addmethod (this_class, (method)irextract_sweep, "sweep", A_GIMME, 0L);
	class_addmethod (this_class, (method)irextract_mls, "mls", A_GIMME, 0L);
	class_addmethod (this_class, (method)irextract_noise, "white", A_GIMME, 0L);
	class_addmethod (this_class, (method)irextract_noise, "brown", A_GIMME, 0L);
	class_addmethod (this_class, (method)irextract_noise, "pink", A_GIMME, 0L);
		
	class_addmethod (this_class, (method)irextract_clear, "clear", 0L);

	class_addmethod (this_class, (method)irextract_getir, "getir", A_GIMME, 0L);
	class_addmethod (this_class, (method)irextract_dump, "dump", A_GIMME, 0L);
	
	declare_HIRT_common_attributes(this_class);
	
	CLASS_ATTR_DOUBLE(this_class, "amp", 0, t_irextract, amp); 
	CLASS_ATTR_LABEL(this_class,"amp", 0, "Signal Amplitude (dB)");

	CLASS_ATTR_LONG(this_class, "invamp", 0, t_irextract, inv_amp); 
	CLASS_ATTR_STYLE_LABEL(this_class,"invamp",0,"onoff","Invert Amplitude");
	
	CLASS_ATTR_LONG(this_class, "bandlimit", 0, t_irextract, bandlimit); 
	CLASS_ATTR_STYLE_LABEL(this_class,"bandlimit",0,"onoff","Bandlimit Sweep Measurements");	
		
	class_register(CLASS_BOX, this_class);
		
	buffer_access_init();
		
	return 0;
}

int C74_EXPORT main()
{
	
#ifdef MSP_VERSION
	
	this_class = class_new("randomvals~",
						   (method)randomvals_new,
						   (method)randomvals_free,
						   sizeof(t_randomvals), 
						   NULL, 
						   A_DEFLONG, 
						   0);
	
	class_addmethod(this_class, (method)randomvals_dsp, "dsp", A_CANT, 0);
	class_addmethod(this_class, (method)randomvals_dsp64, "dsp64", A_CANT, 0);
	
	class_dspinit(this_class);
	
#else
	
	this_class = class_new("randomvals",
						   (method)randomvals_new,
						   (method)randomvals_free,
						   sizeof(t_randomvals), 
						   NULL, 
						   A_DEFLONG, 
						   0);
	
	class_addmethod(this_class, (method)randomvals_int, "int", A_LONG, 0);
	
#endif
	
	class_addmethod(this_class, (method)randomvals_list, "list", A_GIMME, 0);
	class_addmethod(this_class, (method)randomvals_assist, "assist", A_CANT, 0);
	
	
	class_register(CLASS_BOX, this_class);
	
	return 0;
}