I usually write functions for Datastores only. If I need to apply the function to a Datawindow, I convert the Datawindow to a Datastore first. I've written a small function to do this:

public function datastore of_dwtods (datawindow adw_source, dwbuffer adwb_source)

n_ds lds_store

lds_store = create n_ds
lds_store.dataobject = adw_source.dataobject
lds_store.create( adw_source.describe('DataWindow.Syntax') )

adw_source.rowscopy(1, adw_source.rowcount(), adwb_source, lds_store, 1, adwb_source )

return lds_store

[Disclaimer: I use a create here because I sometimes use this function on Datawindows that have their syntax altered via modify. Otherwise the rowscopy might not work if columns are added that weren't in the original dataobject

n_ds is inherited from datastore, should work with the standard dataype just as well]

You could probably leave out the rowscopy and have the target Datawindow share its data with the Datastore created by this function instead. This way, changes to the data would automatically be applied to the target Datawindow. Otherwise you'd have to copy the rows back to the DW.

the link below is the presentation i did on this topic from this year's elevate - how to create a common ancestor so you can do exactly what you asked about.  Also talk about pros/cons of all the options to this (dynamic, if/then, overloading, shared).

DataWindow and DataStore Missing Link - YouTube

Hi, Arnaud -

Arthur is correct when he states the common ancestor to both is PowerObject. Your premise that there should be a common ancestor providing the data-related functions because the methods are identical is not correct. Yes, the data manipulation methods are identical, but that is by design because the DataStore was intended to be a non-visual DataWindow, not because there is a common ancestor that provides this functionality.

Have you considered using ShareData? DataWindows and DataStores can share their data buffers.

You would have to incur the overhead of enabling/disabling data sharing (which I believe is minimal), but then one function would indeed work for both.

Regards, John

And here's the other way around, no need for OpenUserObject() and no need for u_dw object.

See the attached zipped sample:

datawindow ldw_2
datastore lds_temp, lds_toworkwith
any la_data
long ll_i

if apo.typeof() = datawindow! then
    messagebox('debug1', "I'm a DataWindow")
    ldw_2 = apo
    // EDIT: this following comment is absent in the zipped sample app.
    // now make a datastore using the passed in datawindow object:
    lds_toworkwith = create datastore
    lds_toworkwith.dataobject = ldw_2.dataobject
    lds_toworkwith.object.data = ldw_2.object.data
elseif apo.typeof() = datastore! then
    messagebox('debug2', "I'm a DataStore")
    // EDIT: the comment in this zipped sample app. is incorrect, should be above.
    lds_toworkwith = apo
end if

// here you do all the rest of coding of your function:
Messagebox('debug4', lds_toworkwith.rowcount())

destroy lds_toworkwith

here's the little sample app that I spoke about in one of the comments. See attached.

It's in 2019 format, let me know if you need a lower version.

regards,

Yes, when using DYNAMIC, anything will compile.

You said "We tried wrapping a datawindow in a datastore by assigning the dw to the object property of a (new) datastore but this does not work".

Have you tried it the other way around? Like "wrapping a datastore in a datawindow"?

A datawindow has all the properties of a datastore, but a datastore doesn't have all the properties of a datawindow.

Regards.

Hi

You could powerobject instead of datawindow / datastore as type passed and call the functions dynamic.

public subroutine fill_recipe_components(powerobject a_dw)
long ll_index, ll_tot
ll_tot = a_dw.DYNAMIC rowCount()

...

Regards
Arthur