beeps 0.1.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ea954896705b5670bd87500d18d5a8d21f1d9b0
+  data.tar.gz: 6dc87a6062de733daa544cd4603afdd0204b5ca9
+SHA512:
+  metadata.gz: dc4ceeb2878a6f556cd3aa431394d7f1819794b2c8f41232f5b29b7aa2edc6219e8da93efb60a4eb8009c51d52dcf19597670f2a61ac7553d86cb41b08cf5456
+  data.tar.gz: e387bfae183bb0eb46c9ceeda64d6af66de523f8c8aa8f8e7f8a64ed7460e683179218978db57140344bfca2b8d5a6bd22d34d6e947f24ee266e207b72dcc682

data/.doc/ext/beeps/beeps.cpp

@@ -0,0 +1,46 @@
+#include <rucy.h>
+#include "beeps/beeps.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static
+VALUE init(VALUE self)
+{
+	Beeps::init();
+	return self;
+}
+
+static
+VALUE fin(VALUE self)
+{
+	Beeps::fin();
+	return self;
+}
+
+
+static Module mBeeps;
+
+void
+Init_beeps ()
+{
+	mBeeps = rb_define_module("Beeps");
+	mBeeps.define_singleton_method("init!", init);
+	mBeeps.define_singleton_method("fin!", fin);
+}
+
+
+namespace Beeps
+{
+
+
+	Module
+	beeps_module ()
+	{
+		return mBeeps;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/file_in.cpp

@@ -0,0 +1,59 @@
+#include "beeps/ruby/processor.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::FileIn)
+
+#define THIS  to<Beeps::FileIn*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::FileIn, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::FileIn>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE path)
+{
+	RUCY_CHECK_OBJ(Beeps::FileIn, self);
+
+	*THIS = Beeps::FileIn(to<const char*>(path));
+	return self;
+}
+
+
+static Class cFileIn;
+
+void
+Init_file_in ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cFileIn = mBeeps.define_class("FileIn", Beeps::processor_class());
+	rb_define_alloc_func(cFileIn, alloc);
+	rb_define_private_method(cFileIn, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	file_in_class ()
+	{
+		return cFileIn;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/native.cpp

@@ -0,0 +1,41 @@
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+void Init_beeps ();
+
+void Init_processor ();
+void Init_sine_wave ();
+void Init_square_wave ();
+void Init_sawtooth_wave ();
+void Init_file_in ();
+
+void Init_sound ();
+
+
+extern "C" void
+#ifdef COCOAPODS
+	Init_beeps_native ()
+#else
+	Init_native ()
+#endif
+{
+	RUCY_TRY
+
+	Rucy::init();
+
+	Init_beeps();
+
+	Init_processor();
+	Init_sine_wave();
+	Init_square_wave();
+	Init_sawtooth_wave();
+	Init_file_in();
+
+	Init_sound();
+
+	RUCY_CATCH
+}

data/.doc/ext/beeps/processor.cpp

@@ -0,0 +1,49 @@
+#include "beeps/ruby/processor.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::Processor)
+
+#define THIS  to<Beeps::Processor*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::Processor, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	beeps_error(__FILE__, __LINE__);
+}
+
+
+static Class cProcessor;
+
+void
+Init_processor ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cProcessor = rb_define_class_under(mBeeps, "Processor", rb_cObject);
+	rb_define_alloc_func(cProcessor, alloc);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	processor_class ()
+	{
+		return cProcessor;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/sawtooth_wave.cpp

@@ -0,0 +1,66 @@
+#include "beeps/ruby/processor.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::SawtoothWave)
+
+#define THIS  to<Beeps::SawtoothWave*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::SawtoothWave, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::SawtoothWave>(klass);
+}
+
+static
+VALUE set_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+	THIS->set_frequency(frequency.as_f(true));
+	return self;
+}
+
+static
+VALUE frequency(VALUE self)
+{
+	CHECK;
+	return to<float>(THIS->frequency());
+}
+
+
+static Class cSawtoothWave;
+
+void
+Init_sawtooth_wave ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSawtoothWave = mBeeps.define_class("SawtoothWave", Beeps::processor_class());
+	rb_define_alloc_func(cSawtoothWave, alloc);
+	rb_define_method(cSawtoothWave, "frequency=", RUBY_METHOD_FUNC(set_frequency), 1);
+	rb_define_method(cSawtoothWave, "frequency", RUBY_METHOD_FUNC(frequency), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	sawtooth_wave_class ()
+	{
+		return cSawtoothWave;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/sine_wave.cpp

@@ -0,0 +1,66 @@
+#include "beeps/ruby/processor.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::SineWave)
+
+#define THIS  to<Beeps::SineWave*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::SineWave, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::SineWave>(klass);
+}
+
+static
+VALUE set_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+	THIS->set_frequency(frequency.as_f(true));
+	return self;
+}
+
+static
+VALUE frequency(VALUE self)
+{
+	CHECK;
+	return to<float>(THIS->frequency());
+}
+
+
+static Class cSineWave;
+
+void
+Init_sine_wave ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSineWave = mBeeps.define_class("SineWave", Beeps::processor_class());
+	rb_define_alloc_func(cSineWave, alloc);
+	rb_define_method(cSineWave, "frequency=", RUBY_METHOD_FUNC(set_frequency), 1);
+	rb_define_method(cSineWave, "frequency", RUBY_METHOD_FUNC(frequency), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	sine_wave_class ()
+	{
+		return cSineWave;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/sound.cpp

@@ -0,0 +1,69 @@
+#include "beeps/ruby/sound.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::Sound)
+
+#define THIS  to<Beeps::Sound*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::Sound, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::Sound>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE processor, VALUE seconds)
+{
+	RUCY_CHECK_OBJ(Beeps::Sound, self);
+
+	*THIS = Beeps::Sound(to<Beeps::Processor*>(processor), to<float>(seconds));
+	return self;
+}
+
+static
+VALUE play(VALUE self)
+{
+	CHECK;
+
+	THIS->play();
+	return self;
+}
+
+
+static Class cSound;
+
+void
+Init_sound ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSound = rb_define_class_under(mBeeps, "Sound", rb_cObject);
+	rb_define_alloc_func(cSound, alloc);
+	rb_define_private_method(cSound, "initialize", RUBY_METHOD_FUNC(initialize), 2);
+	rb_define_method(cSound, "play", RUBY_METHOD_FUNC(play), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	sound_class ()
+	{
+		return cSound;
+	}
+
+
+}// Beeps

data/.doc/ext/beeps/square_wave.cpp

@@ -0,0 +1,66 @@
+#include "beeps/ruby/processor.h"
+
+
+#include <rucy.h>
+#include "beeps/exception.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Beeps::SquareWave)
+
+#define THIS  to<Beeps::SquareWave*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Beeps::SquareWave, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Beeps::SquareWave>(klass);
+}
+
+static
+VALUE set_frequency(VALUE self, VALUE frequency)
+{
+	CHECK;
+	THIS->set_frequency(frequency.as_f(true));
+	return self;
+}
+
+static
+VALUE frequency(VALUE self)
+{
+	CHECK;
+	return to<float>(THIS->frequency());
+}
+
+
+static Class cSquareWave;
+
+void
+Init_square_wave ()
+{
+	Module mBeeps = rb_define_module("Beeps");
+
+	cSquareWave = mBeeps.define_class("SquareWave", Beeps::processor_class());
+	rb_define_alloc_func(cSquareWave, alloc);
+	rb_define_method(cSquareWave, "frequency=", RUBY_METHOD_FUNC(set_frequency), 1);
+	rb_define_method(cSquareWave, "frequency", RUBY_METHOD_FUNC(frequency), 0);
+}
+
+
+namespace Beeps
+{
+
+
+	Class
+	square_wave_class ()
+	{
+		return cSquareWave;
+	}
+
+
+}// Beeps