path: root/squirrel_3_0_1_stable/sqplus/SquirrelObject.h

#ifndef _SQUIRREL_OBJECT_H_
#define _SQUIRREL_OBJECT_H_

class SquirrelObject
{
  friend class SquirrelVM;
  
public:
  SquirrelObject();
  virtual ~SquirrelObject();
  SquirrelObject(const SquirrelObject & o);
  SquirrelObject(HSQOBJECT o);
  
#if 1
  template <typename _ty>
  SquirrelObject(const _ty & val) { sq_resetobject(&_o); Set((_ty &)val); } // Cast away const to avoid compiler SqPlus::Push() match issue.
  template <typename _ty>
  SquirrelObject(_ty & val) { sq_resetobject(&_o); Set(val); }
  template <typename _ty>
  SquirrelObject(_ty * val) { sq_resetobject(&_o); SetByValue(val); } // Set() would also be OK here. SetByValue() to save potential compiler overhead.
#endif

  SquirrelObject & operator = (HSQOBJECT ho);
  SquirrelObject & operator = (const SquirrelObject &o);
  SquirrelObject & operator = (int n);
  SquirrelObject & operator = (HSQUIRRELVM v);
  
  operator HSQOBJECT& (){ return _o; } 
  bool operator ==(const SquirrelObject& o);
  bool CompareUserPointer(const SquirrelObject& o);
  
  void AttachToStackObject(int idx);
  void Reset(void); // Release (any) reference and reset _o.
  SquirrelObject Clone();
  BOOL SetValue(const SquirrelObject &key,const SquirrelObject &val);
  
  BOOL SetValue(SQInteger key,const SquirrelObject &val);
  BOOL SetValue(INT key,bool b); // Compiler treats SQBool as INT.
  BOOL SetValue(INT key,INT n);
  BOOL SetValue(INT key,FLOAT f);
  BOOL SetValue(INT key,const SQChar *s);

  BOOL SetValue(const SQChar *key,const SquirrelObject &val);
  BOOL SetValue(const SQChar *key,bool b);
  BOOL SetValue(const SQChar *key,INT n);
  BOOL SetValue(const SQChar *key,FLOAT f);
  BOOL SetValue(const SQChar *key,const SQChar *s);

  BOOL SetUserPointer(const SQChar * key,SQUserPointer up);
  SQUserPointer GetUserPointer(const SQChar * key);
  BOOL SetUserPointer(INT key,SQUserPointer up);
  SQUserPointer GetUserPointer(INT key);

  BOOL NewUserData(const SQChar * key,INT size,SQUserPointer * typetag=0);
  BOOL GetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);
  BOOL RawGetUserData(const SQChar * key,SQUserPointer * data,SQUserPointer * typetag=0);

  // === BEGIN Arrays ===

  BOOL ArrayResize(INT newSize);
  BOOL ArrayExtend(INT amount);
  BOOL ArrayReverse(void);
  SquirrelObject ArrayPop(SQBool returnPoppedVal=SQTrue);

  void ArrayAppend(const SquirrelObject &o);

  template<typename T>
  BOOL ArrayAppend(T item);

  // === END Arrays ===

  BOOL SetInstanceUP(SQUserPointer up);
  BOOL IsNull() const;
  int IsNumeric() const;
  int Len() const;
  BOOL SetDelegate(SquirrelObject &obj);
  SquirrelObject GetDelegate();
  const SQChar* ToString();
  bool ToBool();
  SQInteger ToInteger();
  SQFloat ToFloat();
  SQUserPointer GetInstanceUP(SQUserPointer tag) const;
  SquirrelObject GetValue(const SQChar *key) const;
  BOOL Exists(const SQChar *key) const;
  FLOAT GetFloat(const SQChar *key) const;
  INT GetInt(const SQChar *key) const;
  const SQChar *GetString(const SQChar *key) const;
  bool GetBool(const SQChar *key) const;
  SquirrelObject GetValue(INT key) const;
  FLOAT GetFloat(INT key) const;
  INT GetInt(INT key) const;
  const SQChar *GetString(INT key) const;
  bool GetBool(INT key) const;
  SquirrelObject GetAttributes(const SQChar *key = NULL);
  SQObjectType GetType();
  HSQOBJECT & GetObjectHandle() const {return *(HSQOBJECT*)&_o;}
  BOOL BeginIteration();
  BOOL Next(SquirrelObject &key,SquirrelObject &value);
  void EndIteration();

  BOOL GetTypeTag(SQUserPointer * typeTag);

  // === Get the type name of item/object through string key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).
  const SQChar * GetTypeName(const SQChar * key);
  // === Get the type name of item/object through INT key in a table or class. Returns NULL if the type name is not set (not an SqPlus registered type).
  const SQChar * GetTypeName(INT key);
  // === Get the type name of this object, else return NULL if not an SqPlus registered type.
  const SQChar * GetTypeName(void);

  // === Return base class of object using sq_getbase() === 
  SquirrelObject GetBase();
  
  // === BEGIN code suggestion from the Wiki ===
  // Get any bound type from this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
  template<typename _ty>
  _ty Get(void);

  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
  template<typename _ty>
  SquirrelObject SetByValue(_ty val); // classes/structs should be passed by ref (below) to avoid an extra copy.

  // Set any bound type to this SquirrelObject. Note that Squirrel's handling of references and pointers still holds here.
  template<typename _ty>
  SquirrelObject &Set(_ty & val);

  // === END code suggestion from the Wiki ===

private:
  BOOL GetSlot(const SQChar *name) const;
  BOOL RawGetSlot(const SQChar *name) const;
  BOOL GetSlot(INT key) const;
  HSQOBJECT _o;
};

struct StackHandler {
  StackHandler(HSQUIRRELVM v) {
    _top = sq_gettop(v);
    this->v = v;
  }
  SQFloat GetFloat(int idx) {
    SQFloat x = 0.0f;
    if(idx > 0 && idx <= _top) {
      sq_getfloat(v,idx,&x);
    }
    return x;
  }
  SQInteger GetInt(int idx) {
    SQInteger x = 0;
    if(idx > 0 && idx <= _top) {
      sq_getinteger(v,idx,&x);
    }
    return x;
  }
  HSQOBJECT GetObjectHandle(int idx) {
    HSQOBJECT x;
    if(idx > 0 && idx <= _top) {
      sq_resetobject(&x);
      sq_getstackobj(v,idx,&x);
    }
    return x;
  }
  const SQChar *GetString(int idx)
  {
    const SQChar *x = NULL;
    if(idx > 0 && idx <= _top) {
      sq_getstring(v,idx,&x);
    }
    return x;
  }
  SQUserPointer GetUserPointer(int idx)
  {
    SQUserPointer x = 0;
    if(idx > 0 && idx <= _top) {
      sq_getuserpointer(v,idx,&x);
    }
    return x;
  }
  SQUserPointer GetInstanceUp(int idx,SQUserPointer tag)
  {
    SQUserPointer self;
    if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer*)&self,tag)))
      return NULL;
    return self;
  }
  SQUserPointer GetUserData(int idx,SQUserPointer tag=0)
  {
    SQUserPointer otag;
    SQUserPointer up;
    if(idx > 0 && idx <= _top) {
      if(SQ_SUCCEEDED(sq_getuserdata(v,idx,&up,&otag))) {
        if(tag == otag)
          return up;
      }
    }
    return NULL;
  }
  BOOL GetBool(int idx)
  {
    SQBool ret;
    if(idx > 0 && idx <= _top) {
      if(SQ_SUCCEEDED(sq_getbool(v,idx,&ret)))
        return ret;
    }
    return FALSE;
  }
  int GetType(int idx)
  {
    if(idx > 0 && idx <= _top) {
      return sq_gettype(v,idx);
    }
    return -1;
  }
  
  int GetParamCount() {
    return _top;
  }
  int Return(const SQChar *s)
  {
    sq_pushstring(v,s,-1);
    return 1;
  }
  int Return(FLOAT f)
  {
    sq_pushfloat(v,f);
    return 1;
  }
  int Return(INT i)
  {
    sq_pushinteger(v,i);
    return 1;
	}
	int Return(bool b)
	{
		sq_pushbool(v,b);
		return 1;
	}
  int Return(SQUserPointer p) {
    sq_pushuserpointer(v,p);
    return 1;
  }
	int Return(SquirrelObject &o)
	{
		sq_pushobject(v,o.GetObjectHandle());
		return 1;
	}
	int Return() { return 0; }
	int ThrowError(const SQChar *error) {
		return sq_throwerror(v,error);
	}
  HSQUIRRELVM GetVMPtr() { return v; }
private:
	int _top;
	HSQUIRRELVM v;
};

#endif //_SQUIRREL_OBJECT_H_