BEAST/BSE - Better Audio System and Sound Engine  0.8.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
bseprobe.genidl.hh
Go to the documentation of this file.
00001 
00002 /*-------- begin ../sfi/sfidl generated code --------*/
00003 
00004 
00005 
00006 #include <bse/bsecxxplugin.hh>
00007 
00008 
00009 /* enum prototypes */
00010 
00011 
00012 /* choice prototypes */
00013 
00014 
00015 /* record prototypes */
00016 namespace Bse {
00017 class ProbeFeatures;
00018 typedef Sfi::RecordHandle<ProbeFeatures> ProbeFeaturesHandle;
00019 #define BSE_TYPE_PROBE_FEATURES         BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeFeatures)
00020 class Probe;
00021 typedef Sfi::RecordHandle<Probe> ProbeHandle;
00022 #define BSE_TYPE_PROBE          BSE_CXX_DECLARED_RECORD_TYPE (Bse, Probe)
00023 class ProbeRequest;
00024 typedef Sfi::RecordHandle<ProbeRequest> ProbeRequestHandle;
00025 #define BSE_TYPE_PROBE_REQUEST          BSE_CXX_DECLARED_RECORD_TYPE (Bse, ProbeRequest)
00026 
00027 
00028 /* sequence prototypes */
00029 class ProbeSeq;
00030 #define BSE_TYPE_PROBE_SEQ              BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeSeq)
00031 class ProbeRequestSeq;
00032 #define BSE_TYPE_PROBE_REQUEST_SEQ              BSE_CXX_DECLARED_SEQUENCE_TYPE (Bse, ProbeRequestSeq)
00033 
00034 
00035 /* class prototypes */
00036 
00037 
00038 /* enum definitions */
00039 
00040 
00041 /* sequence definitions */
00042 class ProbeSeq : public Sfi::Sequence< ::Bse::ProbeHandle > {
00043 public:
00044   ProbeSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::ProbeHandle > (n) {}
00045   static inline ::Bse::ProbeSeq from_seq (SfiSeq *seq);
00046   static inline SfiSeq *to_seq (const ::Bse::ProbeSeq & seq);
00047   static inline ::Bse::ProbeSeq value_get_boxed (const GValue *value);
00048   static inline void value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self);
00049   static inline const char* options   () { return ""; }
00050   static inline const char* blurb     () { return ""; }
00051   static inline const char* authors   () { return ""; }
00052   static inline const char* license   () { return ""; }
00053   static inline const char* type_name () { return "BseProbeSeq"; }
00054   static inline GParamSpec* get_element ();
00055 };
00056 
00057 class ProbeRequestSeq : public Sfi::Sequence< ::Bse::ProbeRequestHandle > {
00058 public:
00059   ProbeRequestSeq (unsigned int n = 0) : Sfi::Sequence< ::Bse::ProbeRequestHandle > (n) {}
00060   static inline ::Bse::ProbeRequestSeq from_seq (SfiSeq *seq);
00061   static inline SfiSeq *to_seq (const ::Bse::ProbeRequestSeq & seq);
00062   static inline ::Bse::ProbeRequestSeq value_get_boxed (const GValue *value);
00063   static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self);
00064   static inline const char* options   () { return ""; }
00065   static inline const char* blurb     () { return ""; }
00066   static inline const char* authors   () { return ""; }
00067   static inline const char* license   () { return ""; }
00068   static inline const char* type_name () { return "BseProbeRequestSeq"; }
00069   static inline GParamSpec* get_element ();
00070 };
00071 
00072 
00073 
00074 /* record definitions */
00075 class ProbeFeatures : public ::Sfi::GNewable {
00076 public:
00077   bool probe_range;
00078   bool probe_energie;
00079   bool probe_samples;
00080   bool probe_fft;
00081   static inline ::Bse::ProbeFeaturesHandle from_rec (SfiRec *rec);
00082   static inline SfiRec *to_rec (const ::Bse::ProbeFeaturesHandle & ptr);
00083   static inline ::Bse::ProbeFeaturesHandle value_get_boxed (const GValue *value);
00084   static inline void value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self);
00085   static inline const char* options   () { return ""; }
00086   static inline const char* blurb     () { return ""; }
00087   static inline const char* authors   () { return ""; }
00088   static inline const char* license   () { return ""; }
00089   static inline const char* type_name () { return "BseProbeFeatures"; }
00090   static inline SfiRecFields get_fields ();
00091 };
00092 
00093 class Probe : public ::Sfi::GNewable {
00094 public:
00095   Sfi::Int channel_id;
00096   Sfi::Num block_stamp;
00097   Sfi::Real mix_freq;
00098   ::Bse::ProbeFeaturesHandle probe_features;
00099   Sfi::Real min;
00100   Sfi::Real max;
00101   Sfi::Real energie;
00102   ::Bse::FloatSeq sample_data;
00103   ::Bse::FloatSeq fft_data;
00104   static inline ::Bse::ProbeHandle from_rec (SfiRec *rec);
00105   static inline SfiRec *to_rec (const ::Bse::ProbeHandle & ptr);
00106   static inline ::Bse::ProbeHandle value_get_boxed (const GValue *value);
00107   static inline void value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self);
00108   static inline const char* options   () { return ""; }
00109   static inline const char* blurb     () { return ""; }
00110   static inline const char* authors   () { return ""; }
00111   static inline const char* license   () { return ""; }
00112   static inline const char* type_name () { return "BseProbe"; }
00113   static inline SfiRecFields get_fields ();
00114 };
00115 
00116 class ProbeRequest : public ::Sfi::GNewable {
00117 public:
00118   BseSource* source;
00119   Sfi::Int channel_id;
00120   Sfi::Real frequency;
00121   ::Bse::ProbeFeaturesHandle probe_features;
00122   static inline ::Bse::ProbeRequestHandle from_rec (SfiRec *rec);
00123   static inline SfiRec *to_rec (const ::Bse::ProbeRequestHandle & ptr);
00124   static inline ::Bse::ProbeRequestHandle value_get_boxed (const GValue *value);
00125   static inline void value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self);
00126   static inline const char* options   () { return ""; }
00127   static inline const char* blurb     () { return ""; }
00128   static inline const char* authors   () { return ""; }
00129   static inline const char* license   () { return ""; }
00130   static inline const char* type_name () { return "BseProbeRequest"; }
00131   static inline SfiRecFields get_fields ();
00132 };
00133 
00134 
00135 
00136 /* enum declarations */
00137 
00138 
00139 /* sequence type declarations */
00140 BSE_CXX_DECLARE_SEQUENCE (ProbeSeq);
00141 
00142 BSE_CXX_DECLARE_SEQUENCE (ProbeRequestSeq);
00143 
00144 
00145 
00146 /* record type declarations */
00147 BSE_CXX_DECLARE_RECORD (ProbeFeatures);
00148 
00149 BSE_CXX_DECLARE_RECORD (Probe);
00150 
00151 BSE_CXX_DECLARE_RECORD (ProbeRequest);
00152 
00153 
00154 
00155 /* procedure prototypes */
00156 namespace Procedure {
00157 class source_request_probes;
00158 #define BSE_TYPE_SOURCE_REQUEST_PROBES          BSE_CXX_DECLARED_PROC_TYPE (Bse, source_request_probes)
00159 } // Procedure
00160 
00161 namespace Procedure {
00162 class source_mass_request;
00163 #define BSE_TYPE_SOURCE_MASS_REQUEST            BSE_CXX_DECLARED_PROC_TYPE (Bse, source_mass_request)
00164 } // Procedure
00165 
00166 namespace Procedure {
00167 class source_get_tick_stamp;
00168 #define BSE_TYPE_SOURCE_GET_TICK_STAMP          BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_tick_stamp)
00169 } // Procedure
00170 
00171 namespace Procedure {
00172 class source_get_mix_freq;
00173 #define BSE_TYPE_SOURCE_GET_MIX_FREQ            BSE_CXX_DECLARED_PROC_TYPE (Bse, source_get_mix_freq)
00174 } // Procedure
00175 
00176 
00177 
00178 /* class definitions */
00179 
00180 
00181 /* choice implementations */
00182 
00183 
00184 /* record implementations */
00185 ::Bse::ProbeFeaturesHandle
00186 ProbeFeatures::from_rec (SfiRec *sfi_rec)
00187 {
00188   GValue *element;
00189 
00190   if (!sfi_rec)
00191     return Sfi::INIT_NULL;
00192 
00193   ::Bse::ProbeFeaturesHandle rec = Sfi::INIT_DEFAULT;
00194   element = sfi_rec_get (sfi_rec, "probe_range");
00195   if (element)
00196     rec->probe_range = sfi_value_get_bool (element);
00197   element = sfi_rec_get (sfi_rec, "probe_energie");
00198   if (element)
00199     rec->probe_energie = sfi_value_get_bool (element);
00200   element = sfi_rec_get (sfi_rec, "probe_samples");
00201   if (element)
00202     rec->probe_samples = sfi_value_get_bool (element);
00203   element = sfi_rec_get (sfi_rec, "probe_fft");
00204   if (element)
00205     rec->probe_fft = sfi_value_get_bool (element);
00206   return rec;
00207 }
00208 
00209 SfiRec *
00210 ProbeFeatures::to_rec (const ::Bse::ProbeFeaturesHandle & rec)
00211 {
00212   SfiRec *sfi_rec;
00213   GValue *element;
00214 
00215   if (!rec)
00216     return NULL;
00217 
00218   sfi_rec = sfi_rec_new ();
00219   element = sfi_rec_forced_get (sfi_rec, "probe_range", SFI_TYPE_BOOL);
00220   sfi_value_set_bool (element, rec->probe_range);
00221   element = sfi_rec_forced_get (sfi_rec, "probe_energie", SFI_TYPE_BOOL);
00222   sfi_value_set_bool (element, rec->probe_energie);
00223   element = sfi_rec_forced_get (sfi_rec, "probe_samples", SFI_TYPE_BOOL);
00224   sfi_value_set_bool (element, rec->probe_samples);
00225   element = sfi_rec_forced_get (sfi_rec, "probe_fft", SFI_TYPE_BOOL);
00226   sfi_value_set_bool (element, rec->probe_fft);
00227   return sfi_rec;
00228 }
00229 
00230 ::Bse::ProbeFeaturesHandle
00231 ProbeFeatures::value_get_boxed (const GValue *value)
00232 {
00233   return ::Bse::ProbeFeaturesHandle::value_get_boxed (value);
00234 }
00235 
00236 void
00237 ProbeFeatures::value_set_boxed (GValue *value, const ::Bse::ProbeFeaturesHandle & self)
00238 {
00239   ::Bse::ProbeFeaturesHandle::value_set_boxed (value, self);
00240 }
00241 
00242 SfiRecFields
00243 ProbeFeatures::get_fields()
00244 {
00245   static SfiRecFields rfields = { 0, NULL };
00246   if (!rfields.n_fields)
00247     {
00248       static GParamSpec *fields[4 + 1];
00249       rfields.n_fields = 4;
00250       fields[0] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",739,"probe_range");
00251       fields[1] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",740,"probe_energie");
00252       fields[2] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",741,"probe_samples");
00253       fields[3] = sfidl_pspec_Bool_default (NULL,"/opt/src/beast/bse/bseprobe.idl",742,"probe_fft");
00254       rfields.fields = fields;
00255     }
00256   return rfields;
00257 }
00258 ::Bse::ProbeHandle
00259 Probe::from_rec (SfiRec *sfi_rec)
00260 {
00261   GValue *element;
00262 
00263   if (!sfi_rec)
00264     return Sfi::INIT_NULL;
00265 
00266   ::Bse::ProbeHandle rec = Sfi::INIT_DEFAULT;
00267   element = sfi_rec_get (sfi_rec, "channel_id");
00268   if (element)
00269     rec->channel_id = sfi_value_get_int (element);
00270   element = sfi_rec_get (sfi_rec, "block_stamp");
00271   if (element)
00272     rec->block_stamp = sfi_value_get_num (element);
00273   element = sfi_rec_get (sfi_rec, "mix_freq");
00274   if (element)
00275     rec->mix_freq = sfi_value_get_real (element);
00276   element = sfi_rec_get (sfi_rec, "probe_features");
00277   if (element)
00278     rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
00279   element = sfi_rec_get (sfi_rec, "min");
00280   if (element)
00281     rec->min = sfi_value_get_real (element);
00282   element = sfi_rec_get (sfi_rec, "max");
00283   if (element)
00284     rec->max = sfi_value_get_real (element);
00285   element = sfi_rec_get (sfi_rec, "energie");
00286   if (element)
00287     rec->energie = sfi_value_get_real (element);
00288   element = sfi_rec_get (sfi_rec, "sample_data");
00289   if (element)
00290     rec->sample_data = ::Bse::FloatSeq::value_get_boxed (element);
00291   element = sfi_rec_get (sfi_rec, "fft_data");
00292   if (element)
00293     rec->fft_data = ::Bse::FloatSeq::value_get_boxed (element);
00294   return rec;
00295 }
00296 
00297 SfiRec *
00298 Probe::to_rec (const ::Bse::ProbeHandle & rec)
00299 {
00300   SfiRec *sfi_rec;
00301   GValue *element;
00302 
00303   if (!rec)
00304     return NULL;
00305 
00306   sfi_rec = sfi_rec_new ();
00307   element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
00308   sfi_value_set_int (element, rec->channel_id);
00309   element = sfi_rec_forced_get (sfi_rec, "block_stamp", SFI_TYPE_NUM);
00310   sfi_value_set_num (element, rec->block_stamp);
00311   element = sfi_rec_forced_get (sfi_rec, "mix_freq", SFI_TYPE_REAL);
00312   sfi_value_set_real (element, rec->mix_freq);
00313   element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
00314   ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
00315   element = sfi_rec_forced_get (sfi_rec, "min", SFI_TYPE_REAL);
00316   sfi_value_set_real (element, rec->min);
00317   element = sfi_rec_forced_get (sfi_rec, "max", SFI_TYPE_REAL);
00318   sfi_value_set_real (element, rec->max);
00319   element = sfi_rec_forced_get (sfi_rec, "energie", SFI_TYPE_REAL);
00320   sfi_value_set_real (element, rec->energie);
00321   element = sfi_rec_forced_get (sfi_rec, "sample_data", SFI_TYPE_SEQ);
00322   ::Bse::FloatSeq::value_set_boxed (element, rec->sample_data);
00323   element = sfi_rec_forced_get (sfi_rec, "fft_data", SFI_TYPE_SEQ);
00324   ::Bse::FloatSeq::value_set_boxed (element, rec->fft_data);
00325   return sfi_rec;
00326 }
00327 
00328 ::Bse::ProbeHandle
00329 Probe::value_get_boxed (const GValue *value)
00330 {
00331   return ::Bse::ProbeHandle::value_get_boxed (value);
00332 }
00333 
00334 void
00335 Probe::value_set_boxed (GValue *value, const ::Bse::ProbeHandle & self)
00336 {
00337   ::Bse::ProbeHandle::value_set_boxed (value, self);
00338 }
00339 
00340 SfiRecFields
00341 Probe::get_fields()
00342 {
00343   static SfiRecFields rfields = { 0, NULL };
00344   if (!rfields.n_fields)
00345     {
00346       static GParamSpec *fields[9 + 1];
00347       rfields.n_fields = 9;
00348       fields[0] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",746,"channel_id");
00349       fields[1] = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",747,"block_stamp");
00350       fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",748,"mix_freq");
00351       fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",749, "probe_features", Bse::ProbeFeatures::get_fields());
00352       fields[4] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",750,"min");
00353       fields[5] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",751,"max");
00354       fields[6] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",752,"energie");
00355       fields[7] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",753, "sample_data", Bse::FloatSeq::get_element());
00356       fields[8] = sfidl_pspec_Sequence_default (NULL,"/opt/src/beast/bse/bseprobe.idl",754, "fft_data", Bse::FloatSeq::get_element());
00357       rfields.fields = fields;
00358     }
00359   return rfields;
00360 }
00361 ::Bse::ProbeRequestHandle
00362 ProbeRequest::from_rec (SfiRec *sfi_rec)
00363 {
00364   GValue *element;
00365 
00366   if (!sfi_rec)
00367     return Sfi::INIT_NULL;
00368 
00369   ::Bse::ProbeRequestHandle rec = Sfi::INIT_DEFAULT;
00370   element = sfi_rec_get (sfi_rec, "source");
00371   if (element)
00372     rec->source = ::Bse::CxxBase::value_get_gobject< BseSource> (element);
00373   element = sfi_rec_get (sfi_rec, "channel_id");
00374   if (element)
00375     rec->channel_id = sfi_value_get_int (element);
00376   element = sfi_rec_get (sfi_rec, "frequency");
00377   if (element)
00378     rec->frequency = sfi_value_get_real (element);
00379   element = sfi_rec_get (sfi_rec, "probe_features");
00380   if (element)
00381     rec->probe_features = ::Bse::ProbeFeatures::value_get_boxed (element);
00382   return rec;
00383 }
00384 
00385 SfiRec *
00386 ProbeRequest::to_rec (const ::Bse::ProbeRequestHandle & rec)
00387 {
00388   SfiRec *sfi_rec;
00389   GValue *element;
00390 
00391   if (!rec)
00392     return NULL;
00393 
00394   sfi_rec = sfi_rec_new ();
00395   element = sfi_rec_forced_get (sfi_rec, "source", SFI_TYPE_PROXY);
00396   ::Bse::CxxBase::value_set_gobject (element, rec->source);
00397   element = sfi_rec_forced_get (sfi_rec, "channel_id", SFI_TYPE_INT);
00398   sfi_value_set_int (element, rec->channel_id);
00399   element = sfi_rec_forced_get (sfi_rec, "frequency", SFI_TYPE_REAL);
00400   sfi_value_set_real (element, rec->frequency);
00401   element = sfi_rec_forced_get (sfi_rec, "probe_features", SFI_TYPE_REC);
00402   ::Bse::ProbeFeatures::value_set_boxed (element, rec->probe_features);
00403   return sfi_rec;
00404 }
00405 
00406 ::Bse::ProbeRequestHandle
00407 ProbeRequest::value_get_boxed (const GValue *value)
00408 {
00409   return ::Bse::ProbeRequestHandle::value_get_boxed (value);
00410 }
00411 
00412 void
00413 ProbeRequest::value_set_boxed (GValue *value, const ::Bse::ProbeRequestHandle & self)
00414 {
00415   ::Bse::ProbeRequestHandle::value_set_boxed (value, self);
00416 }
00417 
00418 SfiRecFields
00419 ProbeRequest::get_fields()
00420 {
00421   static SfiRecFields rfields = { 0, NULL };
00422   if (!rfields.n_fields)
00423     {
00424       static GParamSpec *fields[4 + 1];
00425       rfields.n_fields = 4;
00426       fields[0] = sfidl_pspec_Object_default (NULL,"/opt/src/beast/bse/bseprobe.idl",761,"source");
00427       fields[1] = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",762,"channel_id");
00428       fields[2] = sfidl_pspec_Real_default (NULL,"/opt/src/beast/bse/bseprobe.idl",763,"frequency");
00429       fields[3] = sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",764, "probe_features", Bse::ProbeFeatures::get_fields());
00430       rfields.fields = fields;
00431     }
00432   return rfields;
00433 }
00434 
00435 
00436 /* sequence implementations */
00437 ::Bse::ProbeSeq
00438 ProbeSeq::from_seq (SfiSeq *sfi_seq)
00439 {
00440   ::Bse::ProbeSeq cseq;
00441   guint i, length;
00442 
00443   if (!sfi_seq)
00444     return cseq;
00445 
00446   length = sfi_seq_length (sfi_seq);
00447   cseq.resize (length);
00448   for (i = 0; i < length; i++)
00449     {
00450       GValue *element = sfi_seq_get (sfi_seq, i);
00451       cseq[i] = ::Bse::Probe::value_get_boxed (element);
00452     }
00453   return cseq;
00454 }
00455 
00456 SfiSeq *
00457 ProbeSeq::to_seq (const ::Bse::ProbeSeq & cseq)
00458 {
00459   SfiSeq *sfi_seq = sfi_seq_new ();
00460   for (guint i = 0; i < cseq.length(); i++)
00461     {
00462       GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
00463       ::Bse::Probe::value_set_boxed (element, cseq[i]);
00464     }
00465   return sfi_seq;
00466 }
00467 
00468 ::Bse::ProbeSeq
00469 ProbeSeq::value_get_boxed (const GValue *value)
00470 {
00471   return ::Sfi::cxx_value_get_boxed_sequence< ProbeSeq> (value);
00472 }
00473 
00474 void
00475 ProbeSeq::value_set_boxed (GValue *value, const ::Bse::ProbeSeq & self)
00476 {
00477   ::Sfi::cxx_value_set_boxed_sequence< ProbeSeq> (value, self);
00478 }
00479 
00480 GParamSpec*
00481 ProbeSeq::get_element()
00482 {
00483   static GParamSpec *element = NULL;
00484   if (!element) {
00485     element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",757, "probes", Bse::Probe::get_fields()));
00486     g_param_spec_sink (element);
00487   }
00488   return element;
00489 }
00490 
00491 ::Bse::ProbeRequestSeq
00492 ProbeRequestSeq::from_seq (SfiSeq *sfi_seq)
00493 {
00494   ::Bse::ProbeRequestSeq cseq;
00495   guint i, length;
00496 
00497   if (!sfi_seq)
00498     return cseq;
00499 
00500   length = sfi_seq_length (sfi_seq);
00501   cseq.resize (length);
00502   for (i = 0; i < length; i++)
00503     {
00504       GValue *element = sfi_seq_get (sfi_seq, i);
00505       cseq[i] = ::Bse::ProbeRequest::value_get_boxed (element);
00506     }
00507   return cseq;
00508 }
00509 
00510 SfiSeq *
00511 ProbeRequestSeq::to_seq (const ::Bse::ProbeRequestSeq & cseq)
00512 {
00513   SfiSeq *sfi_seq = sfi_seq_new ();
00514   for (guint i = 0; i < cseq.length(); i++)
00515     {
00516       GValue *element = sfi_seq_append_empty (sfi_seq, SFI_TYPE_REC);
00517       ::Bse::ProbeRequest::value_set_boxed (element, cseq[i]);
00518     }
00519   return sfi_seq;
00520 }
00521 
00522 ::Bse::ProbeRequestSeq
00523 ProbeRequestSeq::value_get_boxed (const GValue *value)
00524 {
00525   return ::Sfi::cxx_value_get_boxed_sequence< ProbeRequestSeq> (value);
00526 }
00527 
00528 void
00529 ProbeRequestSeq::value_set_boxed (GValue *value, const ::Bse::ProbeRequestSeq & self)
00530 {
00531   ::Sfi::cxx_value_set_boxed_sequence< ProbeRequestSeq> (value, self);
00532 }
00533 
00534 GParamSpec*
00535 ProbeRequestSeq::get_element()
00536 {
00537   static GParamSpec *element = NULL;
00538   if (!element) {
00539     element = g_param_spec_ref (sfidl_pspec_Record_default (NULL,"/opt/src/beast/bse/bseprobe.idl",767, "probe_requests", Bse::ProbeRequest::get_fields()));
00540     g_param_spec_sink (element);
00541   }
00542   return element;
00543 }
00544 
00545 
00546 
00547 /* class implementations */
00548 
00549 
00550 /* procedure implementations */
00551 namespace Procedure {
00552 BSE_CXX_DECLARE_PROC (source_request_probes);
00553 class source_request_probes {
00554 public:
00555   static inline const unsigned char* pixstream () { return NULL; }
00556   static inline const char* options   () { return ""; }
00557   static inline const char* category  () { static const char *c = NULL;
00558     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00559   static inline const char* i18n_category  () { static const char *c = NULL;
00560     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00561   static inline const char* blurb     () { return ""; }
00562   static inline const char* authors   () { return ""; }
00563   static inline const char* license   () { return ""; }
00564   static inline const char* type_name () { return "bse-source-request-probes"; }
00565   static void exec (BseSource* source, Sfi::Int ochannel_id, const ::Bse::ProbeFeaturesHandle & probe_features);
00566   static BseErrorType marshal (BseProcedureClass *procedure,
00567                                const GValue      *in_values,
00568                                GValue            *out_values)
00569   {
00570     try {
00571         exec (
00572               ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0),
00573               sfi_value_get_int (in_values + 1),
00574               ::Bse::ProbeFeatures::value_get_boxed (in_values + 2) 
00575              );
00576     } catch (std::exception &e) {
00577       sfi_diag ("%s: %s", "source_request_probes", e.what());
00578       return BSE_ERROR_PROC_EXECUTION;
00579     } catch (...) {
00580       sfi_diag ("%s: %s", "source_request_probes", "uncaught exception");
00581       return BSE_ERROR_PROC_EXECUTION;
00582     }
00583     return BSE_ERROR_NONE;
00584   }
00585   static void init (BseProcedureClass *proc,
00586                     GParamSpec       **in_pspecs,
00587                     GParamSpec       **out_pspecs)
00588   {
00589     *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "source", BSE_TYPE_SOURCE);
00590     *(in_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0,"ochannel_id");
00591     *(in_pspecs++) = sfidl_pspec_BoxedRec_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "probe_features", BSE_TYPE_PROBE_FEATURES);
00592   }
00593 };
00594 } // Procedure
00595 
00596 namespace Procedure {
00597 BSE_CXX_DECLARE_PROC (source_mass_request);
00598 class source_mass_request {
00599 public:
00600   static inline const unsigned char* pixstream () { return NULL; }
00601   static inline const char* options   () { return ""; }
00602   static inline const char* category  () { static const char *c = NULL;
00603     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00604   static inline const char* i18n_category  () { static const char *c = NULL;
00605     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00606   static inline const char* blurb     () { return ""; }
00607   static inline const char* authors   () { return ""; }
00608   static inline const char* license   () { return ""; }
00609   static inline const char* type_name () { return "bse-source-mass-request"; }
00610   static void exec (const ::Bse::ProbeRequestSeq & prseq);
00611   static BseErrorType marshal (BseProcedureClass *procedure,
00612                                const GValue      *in_values,
00613                                GValue            *out_values)
00614   {
00615     try {
00616         exec (
00617               ::Bse::ProbeRequestSeq::value_get_boxed (in_values + 0) 
00618              );
00619     } catch (std::exception &e) {
00620       sfi_diag ("%s: %s", "source_mass_request", e.what());
00621       return BSE_ERROR_PROC_EXECUTION;
00622     } catch (...) {
00623       sfi_diag ("%s: %s", "source_mass_request", "uncaught exception");
00624       return BSE_ERROR_PROC_EXECUTION;
00625     }
00626     return BSE_ERROR_NONE;
00627   }
00628   static void init (BseProcedureClass *proc,
00629                     GParamSpec       **in_pspecs,
00630                     GParamSpec       **out_pspecs)
00631   {
00632     *(in_pspecs++) = sfidl_pspec_BoxedSeq_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "prseq", BSE_TYPE_PROBE_REQUEST_SEQ);
00633   }
00634 };
00635 } // Procedure
00636 
00637 namespace Procedure {
00638 BSE_CXX_DECLARE_PROC (source_get_tick_stamp);
00639 class source_get_tick_stamp {
00640 public:
00641   static inline const unsigned char* pixstream () { return NULL; }
00642   static inline const char* options   () { return ""; }
00643   static inline const char* category  () { static const char *c = NULL;
00644     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00645   static inline const char* i18n_category  () { static const char *c = NULL;
00646     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00647   static inline const char* blurb     () { return ""; }
00648   static inline const char* authors   () { return ""; }
00649   static inline const char* license   () { return ""; }
00650   static inline const char* type_name () { return "bse-source-get-tick-stamp"; }
00651   static Sfi::Num exec (BseSource* obj);
00652   static BseErrorType marshal (BseProcedureClass *procedure,
00653                                const GValue      *in_values,
00654                                GValue            *out_values)
00655   {
00656     try {
00657       Sfi::Num __return_value =
00658         exec (
00659               ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0) 
00660              );
00661       sfi_value_set_num (out_values, __return_value);
00662     } catch (std::exception &e) {
00663       sfi_diag ("%s: %s", "source_get_tick_stamp", e.what());
00664       return BSE_ERROR_PROC_EXECUTION;
00665     } catch (...) {
00666       sfi_diag ("%s: %s", "source_get_tick_stamp", "uncaught exception");
00667       return BSE_ERROR_PROC_EXECUTION;
00668     }
00669     return BSE_ERROR_NONE;
00670   }
00671   static void init (BseProcedureClass *proc,
00672                     GParamSpec       **in_pspecs,
00673                     GParamSpec       **out_pspecs)
00674   {
00675     *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE);
00676     *(out_pspecs++) = sfidl_pspec_Num_default (NULL,"/opt/src/beast/bse/bseprobe.idl",20247104,"result");
00677   }
00678 };
00679 } // Procedure
00680 
00681 namespace Procedure {
00682 BSE_CXX_DECLARE_PROC (source_get_mix_freq);
00683 class source_get_mix_freq {
00684 public:
00685   static inline const unsigned char* pixstream () { return NULL; }
00686   static inline const char* options   () { return ""; }
00687   static inline const char* category  () { static const char *c = NULL;
00688     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00689   static inline const char* i18n_category  () { static const char *c = NULL;
00690     return c ? c : c = sfi_category_concat ("/Proc", ""); }
00691   static inline const char* blurb     () { return ""; }
00692   static inline const char* authors   () { return ""; }
00693   static inline const char* license   () { return ""; }
00694   static inline const char* type_name () { return "bse-source-get-mix-freq"; }
00695   static Sfi::Int exec (BseSource* obj);
00696   static BseErrorType marshal (BseProcedureClass *procedure,
00697                                const GValue      *in_values,
00698                                GValue            *out_values)
00699   {
00700     try {
00701       Sfi::Int __return_value =
00702         exec (
00703               ::Bse::CxxBase::value_get_gobject< BseSource> (in_values + 0) 
00704              );
00705       sfi_value_set_int (out_values, __return_value);
00706     } catch (std::exception &e) {
00707       sfi_diag ("%s: %s", "source_get_mix_freq", e.what());
00708       return BSE_ERROR_PROC_EXECUTION;
00709     } catch (...) {
00710       sfi_diag ("%s: %s", "source_get_mix_freq", "uncaught exception");
00711       return BSE_ERROR_PROC_EXECUTION;
00712     }
00713     return BSE_ERROR_NONE;
00714   }
00715   static void init (BseProcedureClass *proc,
00716                     GParamSpec       **in_pspecs,
00717                     GParamSpec       **out_pspecs)
00718   {
00719     *(in_pspecs++) = sfidl_pspec_TypedObject_default (NULL,"/opt/src/beast/bse/bseprobe.idl",0, "obj", BSE_TYPE_SOURCE);
00720     *(out_pspecs++) = sfidl_pspec_Int_default (NULL,"/opt/src/beast/bse/bseprobe.idl",20247104,"result");
00721   }
00722 };
00723 } // Procedure
00724 
00725 
00726 
00727 /* bseprobe.idl type registrations */
00728 #define BSE_CXX_REGISTER_ALL_TYPES_FROM_BSEPROBE_IDL() \
00729   BSE_CXX_REGISTER_RECORD (ProbeFeatures); \
00730   BSE_CXX_REGISTER_RECORD (Probe); \
00731   BSE_CXX_REGISTER_RECORD (ProbeRequest); \
00732   BSE_CXX_REGISTER_SEQUENCE (ProbeSeq); \
00733   BSE_CXX_REGISTER_SEQUENCE (ProbeRequestSeq); \
00734   BSE_CXX_REGISTER_PROCEDURE (source_request_probes); \
00735   BSE_CXX_REGISTER_PROCEDURE (source_mass_request); \
00736   BSE_CXX_REGISTER_PROCEDURE (source_get_tick_stamp); \
00737   BSE_CXX_REGISTER_PROCEDURE (source_get_mix_freq); \
00738   /* bseprobe.idl type registrations done */
00739 } // Bse
00740 
00741 /*-------- end ../sfi/sfidl generated code --------*/
00742 
00743 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines