Instance?

object (instance) = datafolder 

 - string /g -> string member 
 - variable /g -> numeric member 
 - make -> numeric wave member 
 - make /t -> text wave member 

function foo_init() 
  string /g bar; 
  variable /g bar2; 
  make /n=10 wvar; 
end 

oop_new function accepts a path and class name, and create a datafolder with appropriate initialization.

Function  oop_new(path, classname) 
	string path, classname 
 
	// check for class existence 
	if (exists(classname+"_init") == 0) 
		print "class:", classname, " does not eixst" 
		return -1 
	endif 
	 
	// remember current datafolder 
	string df = getdatafolder(1); 
	 
	// strip off ":" (igor isn't flexible (nor consistent:) in handling pathnames) 
	if (cmpstr(path[strlen(path)-1] , ":") == 0) 
		path = path[0, strlen(path)-2] 
	endif	 
 
	// create datafolder 
	newdatafolder /o/s $(path) 
 
	// inherit Obj class 
	// create string variable 'class', wave 'parents' 
	obj_init(classname) 
 
	// call initialization functions 
	execute (classname+"_init()") 
	 
	// restore datafolder 
	setdatafolder df;	 
	return 0 
End

So the remaining problem in doing basic OOP is how to implement the inheritance and the polymorphism of method call.

function foo_init() 
  obj_inherit("bar") 
  string /g foo1 
  variable /g foo2 
  ... 
end

Function obj_inherit(parentname) 
	string parentname 
	Execute( parentname+"_init()")	// initialization (parents order matters) 
	util_appendToTWave("parents", parentname) // remember parent class 
End 

This way, members of parent classes get created and initialized and parent class names are stored in a special text wave named "parents" in the current datafolder.

(By the way, there is a special string variable named class which keeps class name of the current datafolder. So these names are reserved.)

As can be seen from this implementation, there is no metaclass. Each object keeps track of its own class and inheritance.

Method call is impolemented in a function oop_do. It accepts a path to the datafolder, method name, and arguments converted to a string. E.g.

oop_do("root:foo", "bar", "()") 

method = function classname_methodname(...) 

Function oop_do(path,  method, args) 
	string path, method, args 
	 
	variable count 
	string df = getdatafolder(1) 
 
	if (! datafolderexists(path)) 
		print "object:",path," does not exists." 
		return -1 
	endif 
 
	setdatafolder $(path) 
	SVAR class = class 
	if (exists("class") != 2) 
		print path, " is not a class instance!", ", method = ", \ 
                             method, "args=", args 
		return 0 
	endif 
	 
	wave /t parents= parents 
	 
	// get function name 
	string fname = ""; 
	if (exists( class+"_"+method) == 6)// first check "classname+method" 
		fname =  class+"_"+method; 
	else 
		// no function w/ "classname+method" check "parentname+method" 
		for (count =numpnts(parents)-1; count > -1; count -= 1) 
			if (exists(parents[count]+"_"+method) == 6) 
				fname = parents[count]+"_"+method 
				break 
			endif 
		endfor 
	endif 
	if (cmpstr(fname, "")==0) 
		print "No method exists: obj=", path, " class=", class, " \ 
                       method=", method, args 
		setdatafolder df 
		return -1 
	endif 
 
	// call method 
	Execute(fname+args) 
	 
	if (datafolderexists(df)) 
		setdatafolder df	 
	else 
		setdatafolder $("root:") 
	endif 
	return 0 
End 

An alternative to the above solution is described in OOP file (oop_getFname(obj, method)). oop_getFname returns function reference, so you don't have to encode arguments in a string and you can get return value. But since Igor doesn't allow variable number of arguments (am I wrong?), I couldn't put the whole sequence in one function, so every time you want to call a method, you have to

1. get function ref with oop_getFname
2. set current datafolder to the object's datafolder
3. call the method function
4. restore current datafolder

From method

• SVAR strmembername (for string member access)
• NVAR varmembername (for variable member access)
• wave wavename
• wave /t textwavename

• oop_get_s(path, name)
• oop_get_v(path, name)
• oop_set_s(path, name, value)
• oop_set_v(path, name, value)

 SVAR foostr1 = $("root:foo:str1") 
etc. 

Pitfalls

• Not suited for small & numerous object (many datafolders)
• oop_do : not suited for frequent call (like in huge "for" loop)
• oop_do : requires an argument converted to a string (better use accessors)

But completely OK for opposite cases (infrequent call, no argument, small number of objects, ...).