rhodes 6.2.0 → 7.1.17

data/platform/shared/rhoruby/impl/MutableBooleanImpl.cpp

@@ -0,0 +1,44 @@
+
+#include "MutableBooleanImpl.h"
+#include <stdlib.h>
+
+
+namespace rho {
+namespace ruby {
+
+
+MutableBooleanImpl::MutableBooleanImpl(bool is_mutable) {
+    BASIC_TYPES basicType = BASIC_TYPES::Boolean;
+    if (is_mutable) {
+        basicType = BASIC_TYPES::MutableBoolean;
+    }
+    setBasicType(basicType);
+    mValue = false;
+}
+
+MutableBooleanImpl::MutableBooleanImpl() {
+    mValue = false;
+}
+
+
+MutableBooleanImpl::~MutableBooleanImpl() {
+
+}
+
+const char* MutableBooleanImpl::getClassName() {
+    if (mValue) {
+        return "TrueClass";
+    }
+    return "FalseClass";
+}
+
+bool MutableBooleanImpl::getBool() {
+    return mValue;
+}
+
+void MutableBooleanImpl::setBool(bool value) {
+    mValue = value;
+}
+
+}
+}

data/platform/shared/rhoruby/impl/MutableBooleanImpl.h

@@ -0,0 +1,44 @@
+#pragma once
+
+
+#include "../api/IMutableBoolean.h"
+#include "ObjectImpl.h"
+
+
+namespace rho {
+namespace ruby {
+
+
+
+class MutableBooleanImpl : public ObjectImpl  {
+
+public:
+    MutableBooleanImpl(bool is_mutable);
+    MutableBooleanImpl();
+    virtual ~MutableBooleanImpl();
+
+    virtual const char* getClassName();
+
+    virtual bool getBool();
+    virtual void setBool(bool value);
+
+private:
+    bool mValue;
+};
+
+// C++ is sucks !
+class CMutableBoolean : public IMutableBoolean, public MutableBooleanImpl  {
+public:
+    CMutableBoolean(bool is_mutable):MutableBooleanImpl(is_mutable) {}
+    CMutableBoolean() {}
+    virtual void addRef() {RefCountedObjectImpl::addRef();}
+    virtual void release() {RefCountedObjectImpl::release();}
+    virtual const char* getClassName() {return ObjectImpl::getClassName();}
+    virtual BASIC_TYPES getBasicType() {return ObjectImpl::getBasicType();}
+    virtual bool getBool() {return MutableBooleanImpl::getBool();}
+    virtual void setBool(bool value) {MutableBooleanImpl::setBool(value);}
+};
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableFloatImpl.cpp

@@ -0,0 +1,41 @@
+
+#include "MutableFloatImpl.h"
+#include <stdlib.h>
+
+
+namespace rho {
+namespace ruby {
+
+
+MutableFloatImpl::MutableFloatImpl(bool is_mutable) {
+    BASIC_TYPES basicType = BASIC_TYPES::Float;
+    if (is_mutable) {
+        basicType = BASIC_TYPES::MutableFloat;
+    }
+    setBasicType(basicType);
+    mValue = 0.0;
+}
+
+MutableFloatImpl::MutableFloatImpl() {
+    mValue = 0.0;
+}
+
+
+MutableFloatImpl::~MutableFloatImpl() {
+
+}
+
+const char* MutableFloatImpl::getClassName() {
+    return "Float";
+}
+
+double MutableFloatImpl::getDouble() {
+    return mValue;
+}
+
+void MutableFloatImpl::setDouble(double value) {
+    mValue = value;
+}
+
+}
+}

data/platform/shared/rhoruby/impl/MutableFloatImpl.h

@@ -0,0 +1,44 @@
+#pragma once
+
+
+#include "../api/IMutableFloat.h"
+#include "ObjectImpl.h"
+
+
+namespace rho {
+namespace ruby {
+
+
+
+class MutableFloatImpl : public ObjectImpl  {
+
+public:
+    MutableFloatImpl(bool is_mutable);
+    MutableFloatImpl();
+    virtual ~MutableFloatImpl();
+
+    virtual const char* getClassName();
+
+    virtual double getDouble();
+    virtual void setDouble(double value);
+
+private:
+    double mValue;
+};
+
+// C++ is sucks !
+class CMutableFloat : public IMutableFloat, public MutableFloatImpl  {
+public:
+    CMutableFloat(bool is_mutable):MutableFloatImpl(is_mutable) {}
+    CMutableFloat() {}
+    virtual void addRef() {RefCountedObjectImpl::addRef();}
+    virtual void release() {RefCountedObjectImpl::release();}
+    virtual const char* getClassName() {return ObjectImpl::getClassName();}
+    virtual BASIC_TYPES getBasicType() {return ObjectImpl::getBasicType();}
+    virtual double getDouble() {return MutableFloatImpl::getDouble();}
+    virtual void setDouble(double value) {MutableFloatImpl::setDouble(value);}
+};
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableHashImpl.cpp

@@ -0,0 +1,64 @@
+
+#include "MutableHashImpl.h"
+#include "MutableArrayImpl.h"
+#include "MutableStringImpl.h"
+#include <stdlib.h>
+#include "string.h"
+
+namespace rho {
+namespace ruby {
+
+
+MutableHashImpl::MutableHashImpl(bool is_mutable) {
+    BASIC_TYPES basicType = BASIC_TYPES::Hash;
+    if (is_mutable) {
+        basicType = BASIC_TYPES::MutableHash;
+    }
+    setBasicType(basicType);
+}
+
+MutableHashImpl::MutableHashImpl() {
+}
+
+
+MutableHashImpl::~MutableHashImpl() {
+    std::map<std::string, IObject*>::iterator it = mHash.begin();
+    while(it != mHash.end())
+    {
+        IObject* value = it->second;
+        value->release();
+        it++;
+    }
+}
+
+const char* MutableHashImpl::getClassName() {
+    return "Hash";
+}
+
+IArray* MutableHashImpl::getKeys() {
+    CMutableArray* ar = new CMutableArray(false);
+    std::map<std::string, IObject*>::iterator it = mHash.begin();
+    while(it != mHash.end())
+    {
+        std::string key = it->first;
+        CMutableString* str_key = new CMutableString(false);
+        str_key->setUTF8(key.c_str());
+        ar->addItem(str_key);
+        str_key->release();
+        it++;
+    }
+    return ar;
+}
+
+IObject* MutableHashImpl::getItem(const char* key) {
+    return mHash[key];
+}
+
+void MutableHashImpl::addItem(const char* key, IObject* item) {
+    item->addRef();
+    mHash[key] = item;
+}
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableHashImpl.h

@@ -0,0 +1,49 @@
+#pragma once
+
+
+#include "../api/IMutableHash.h"
+#include "ObjectImpl.h"
+#include <vector>
+#include <string>
+#include <map>
+
+namespace rho {
+namespace ruby {
+
+
+
+class MutableHashImpl : public ObjectImpl  {
+
+public:
+    MutableHashImpl(bool is_mutable);
+    MutableHashImpl();
+    virtual ~MutableHashImpl();
+
+    virtual const char* getClassName();
+
+    virtual IArray* getKeys();
+    virtual IObject* getItem(const char* key);
+    virtual void addItem(const char* key, IObject* item);
+
+
+private:
+    std::map<std::string, IObject*> mHash;
+};
+
+// C++ is sucks !
+class CMutableHash : public IMutableHash, public MutableHashImpl  {
+public:
+    CMutableHash(bool is_mutable):MutableHashImpl(is_mutable) {}
+    CMutableHash() {}
+    virtual void addRef() {RefCountedObjectImpl::addRef();}
+    virtual void release() {RefCountedObjectImpl::release();}
+    virtual const char* getClassName() {return ObjectImpl::getClassName();}
+    virtual BASIC_TYPES getBasicType() {return ObjectImpl::getBasicType();}
+    virtual IArray* getKeys() {return MutableHashImpl::getKeys();}
+    virtual IObject* getItem(const char* key) {return MutableHashImpl::getItem(key);}
+    virtual void addItem(const char* key, IObject* item) {MutableHashImpl::addItem(key, item);}
+};
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableIntegerImpl.cpp

@@ -0,0 +1,41 @@
+
+#include "MutableIntegerImpl.h"
+#include <stdlib.h>
+
+
+namespace rho {
+namespace ruby {
+
+
+MutableIntegerImpl::MutableIntegerImpl(bool is_mutable) {
+    BASIC_TYPES basicType = BASIC_TYPES::Integer;
+    if (is_mutable) {
+        basicType = BASIC_TYPES::MutableInteger;
+    }
+    setBasicType(basicType);
+    mValue = 0;
+}
+
+MutableIntegerImpl::MutableIntegerImpl() {
+    mValue = 0;
+}
+
+
+MutableIntegerImpl::~MutableIntegerImpl() {
+
+}
+
+const char* MutableIntegerImpl::getClassName() {
+    return "Fixnum";
+}
+
+long int MutableIntegerImpl::getLong() {
+    return mValue;
+}
+
+void MutableIntegerImpl::setLong(long int value) {
+    mValue = value;
+}
+
+}
+}

data/platform/shared/rhoruby/impl/MutableIntegerImpl.h

@@ -0,0 +1,44 @@
+#pragma once
+
+
+#include "../api/IMutableInteger.h"
+#include "ObjectImpl.h"
+
+
+namespace rho {
+namespace ruby {
+
+
+
+class MutableIntegerImpl : public ObjectImpl  {
+
+public:
+    MutableIntegerImpl(bool is_mutable);
+    MutableIntegerImpl();
+    virtual ~MutableIntegerImpl();
+
+    virtual const char* getClassName();
+
+    virtual long int getLong();
+    virtual void setLong(long int value);
+
+private:
+    long int mValue;
+};
+
+// C++ is sucks !
+class CMutableInteger : public IMutableInteger, public MutableIntegerImpl  {
+public:
+    CMutableInteger(bool is_mutable):MutableIntegerImpl(is_mutable) {}
+    CMutableInteger() {}
+    virtual void addRef() {RefCountedObjectImpl::addRef();}
+    virtual void release() {RefCountedObjectImpl::release();}
+    virtual const char* getClassName() {return ObjectImpl::getClassName();}
+    virtual BASIC_TYPES getBasicType() {return ObjectImpl::getBasicType();}
+    virtual long int getLong() {return MutableIntegerImpl::getLong();}
+    virtual void setLong(long int value) {MutableIntegerImpl::setLong(value);}
+};
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableStringImpl.cpp

@@ -0,0 +1,52 @@
+
+#include "MutableStringImpl.h"
+#include <stdlib.h>
+#include "string.h"
+
+namespace rho {
+namespace ruby {
+
+
+MutableStringImpl::MutableStringImpl(bool is_mutable) {
+    BASIC_TYPES basicType = BASIC_TYPES::String;
+    if (is_mutable) {
+        basicType = BASIC_TYPES::MutableString;
+    }
+    setBasicType(basicType);
+    mString = NULL;
+}
+    
+MutableStringImpl::MutableStringImpl() {
+    mString = NULL;
+}
+
+
+MutableStringImpl::~MutableStringImpl() {
+    if (mString != NULL) {
+        free(mString);
+    }
+}
+
+const char* MutableStringImpl::getClassName() {
+    return "String";
+}
+
+const char* MutableStringImpl::getUTF8() {
+    return (const char*)mString;
+}
+
+void MutableStringImpl::setUTF8(const char* utf8_string) {
+    if (mString != NULL) {
+        free(mString);
+    }
+    mString = NULL;
+    if (utf8_string != NULL) {
+        int len = (int)strlen(utf8_string);
+        mString = (char*)malloc(len+1);
+        strcpy(mString, utf8_string);
+    }
+}
+
+
+}
+}

data/platform/shared/rhoruby/impl/MutableStringImpl.h

@@ -0,0 +1,44 @@
+#pragma once
+
+
+#include "../api/IMutableString.h"
+#include "ObjectImpl.h"
+
+
+namespace rho {
+namespace ruby {
+
+
+
+class MutableStringImpl : public ObjectImpl  {
+
+public:
+    MutableStringImpl(bool is_mutable);
+    MutableStringImpl();
+    virtual ~MutableStringImpl();
+
+    virtual const char* getClassName();
+
+    virtual const char* getUTF8();
+    virtual void setUTF8(const char* utf8_string);
+    
+private:
+    char* mString;
+};
+
+// C++ is sucks !
+class CMutableString : public IMutableString, public MutableStringImpl  {
+public:
+    CMutableString(bool is_mutable):MutableStringImpl(is_mutable) {}
+    CMutableString() {}
+    virtual void addRef() {RefCountedObjectImpl::addRef();}
+    virtual void release() {RefCountedObjectImpl::release();}
+    virtual const char* getClassName() {return ObjectImpl::getClassName();}
+    virtual BASIC_TYPES getBasicType() {return ObjectImpl::getBasicType();}
+    virtual const char* getUTF8() {return MutableStringImpl::getUTF8();}
+    virtual void setUTF8(const char* utf8_string) {MutableStringImpl::setUTF8(utf8_string);}
+};
+    
+    
+}
+}