The Jagular - Comments

Comment From Jurjen van den Broeck

Jurjen van den Broeck — Tue, 10 Jun 2008 06:37:13 PM -0700

Dear,

I'm looking for the C-API function to create a replication-entry on the repliction page of a database.

Because I'm using a (local) scheduled agent, I'm not allow to use UI like NotesUIWorkspace.

Any help?

Comment From Jay Wetherald

Jay Wetherald — Tue, 12 Feb 2008 08:30:51 AM -0700

Those pictures are awesome.

Comment From Alain H Romedenne

Alain H Romedenne — Sat, 8 Dec 2007 02:58:08 PM -0700

I tend to suspect your problems most probably relate to mal-formed or ancient replication notes. I would not investigate your code content further.

Comment From Jens

Jens — Tue, 29 May 2007 08:39:39 AM -0700

Sure

Replace m_count with m_index and m_count is free to do the counting work. Just a simple example that using one single variable for two independent, distinct functions may heart someday

Comment From Bruce Perry

Bruce Perry — Wed, 9 May 2007 01:52:06 PM -0700

Not decreasing m_count when doing deletes from the middle of the list would work, but at the cost of not knowing the number of items in the list. Since having a count of items was my first goal in creating this class, I'll leave things as they stand for the moment.

Under some circumstances, not decrementing the count would work fine. If you never need a count of the items in the list, there's no problem.

I suspect you're correct about the performance of the code for actually doing the deletes. Unless the list is huge or the number of deletes is huge, the impact shouldn't be excessive.

Comment From Jens

Jens — Fri, 4 May 2007 12:18:45 PM -0700

Sure, your deleteItem method calls for troubles, if you try to delete an item in the middle of the list.

The simplest solution for this problem is to remove the following line:

m_count = m_count-1

That way you produce holes in the list like in a Swiss Cheese so you have to provide for the case, that you do not find an item through the second index. There are other strategies, that may be used to make it even more flexible, that is to remove the holes:

Move down all the entries from the deletion point up to the end of the list and remove the last list entry instead:

m_count = m_count-1
for i=val(m_xreflist(key)) to m_count
m_list(cstr(i))=m_list(cstr(i+1))
next
erase m_list(cstr(i))

Warning: Not tested and not checked for any extreme conditions ....

Shouldn't have too much of an impact except for really big lists

Comment From Jens

Jens — Sun, 1 Apr 2007 01:22:51 PM -0700

Bruce .... look at my comment to your class ...

***
Another point, if you update an entry, you only update the entry, that is accessible by "key", but not the second entry, that is accessible by the count-on-creation.
***

So I already pointed that out back then and gave a way to resolve the problem

Comment From Jens

Jens — Fri, 2 Mar 2007 12:15:15 PM -0700

VMWare Server is not capable of direclty interact with the host system, so your solution isn't that far away. Instead of using a CD/Stick you could define a fileshare on one of the logical systems, the host or the client and then copy things forth and back through the networking functionality. The functionality you are mentioning, direct access from the client to defined portions of the host filesystem is available for example in the VMWare Workstation, which obviously is not for free (but it is definately worth the investment).

Comment From LARRY COOPER

LARRY COOPER — Mon, 26 Feb 2007 04:17:28 PM -0700

Comment From Bruce Perry

Bruce Perry — Fri, 21 Jul 2006 07:10:41 PM -0700

Excellent points! It may be a few days before I can make the revisions, but I will do them soon.

Comment From Tim Crannigan

Tim Crannigan — Fri, 21 Jul 2006 08:54:47 AM -0700

Bruce

Like it! However, I developed a lotusscript library for talking to Excel as we use it a *lot* and found that the
xlsheet.Cells(rows,cols).Value = "" model
whilst quick with small numbers of cells, can become very slow as the date scales up.
Our systems export the data to a tab separated file then use Excel's file import. This is *much* quicker. I ran a test on 2000 rows * 20 columns, and found setting cells directly took 82 seconds. Using the file import took less than 1 second.(suprised even me!)

If you are interested in my library, let me know.

one final thing - I was developing a universal export, but the problem seems to be I can only get the selected *documents* in a view - I can't get the selected entries, which means I can't export view column values e.g. formulae.

Any thoughts on that?

Comment From Jens

Jens — Wed, 19 Jul 2006 10:11:49 PM -0700

You may replace this:

'see if there's an object in the list for a given key
Public Function IsInList(key As String) As Integer
Dim rval As Integer
If ( Iselement(m_List(key)) ) Then
rval = True
Else
rval = False
End If
IsInList = rval
End Function

by this short version:

'see if there's an object in the list for a given key
Public Function IsInList(key As String) As Integer
IsInList = Iselement(m_List(key))
End Function

******

Another point, if you update an entry, you only update the entry, that is accessible by "key", but not the second entry, that is accessible by the count-on-creation.

You probably need a second list, that makes a crossref between the "key" and the "count" part of the list, so it may look something like this:

Public Function AddItem(key As String, item As String) As Integer
'just add the item if the key doesn't exist
If ( Not Iselement(m_List(key)) ) Then
m_list(key) = item
m_count = m_count+1
'a double index so we can walk the list from the count alone
m_list( Cstr(m_count) ) = item
' x-ref the second index:
m_xrefList (key) = Cstr(m_count)
Else
'if the key does exist, erase the current object in the list
'and add the new one
Erase m_List(key)
m_list(key) = item
' do the same with the second index
Erase m_List(m_xrefList(key))
m_List(m_xrefList(key)) = item
End If
End Function

Having that, you may implement the delete funciton accordingly

Comment From Bruce Perry

Bruce Perry — Sun, 16 Jul 2006 06:32:47 PM -0700

Yes, that would work. I could also make it invisible and have a default prefix of something like "xyzzy_"

Comment From Richard Schwartz

Richard Schwartz — Fri, 14 Jul 2006 08:37:26 AM -0700

How about using a settable prefix for the double index? E.g. provide a property Set Prefix, and use m_list(prefix + CStr(count)) = item.

Comment From Bruce Perry

Bruce Perry — Fri, 7 Jul 2006 06:58:30 PM -0700

Cool! It's great to see a chain reaction of inspiration building.

Comment From Richard Schwartz

Richard Schwartz — Thu, 6 Jul 2006 05:22:30 PM -0700

Vince DiMascio has now done an Ajax-ified front end for this.

http://www.vincedimascio.com/vince/vpd.nsf/all/96C9D32C9CE937AE882571A30057307D

-rich

Comment From Mike Smith

Mike Smith — Sat, 3 Jun 2006 11:42:16 PM -0700

Comment From Bruce Perry

Bruce Perry — Mon, 24 Apr 2006 09:19:12 PM -0700

Hmm, lost the most recent two comments when I upgraded to Blogsphere 2.5.3. Maybe adding a comment will do something.

Comment From Bruce Perry

Bruce Perry — Sun, 23 Apr 2006 09:05:08 PM -0700

Excellent point! As it happens, I do have views (too many, in fact) and could almost certainly get that ID from one of them. I bet it would be faster. When time permits, I'll create an alternate version.

Comment From Rob McDonagh

Rob McDonagh — Sun, 23 Apr 2006 01:07:13 PM -0700

I like anything that uses lists. They're blazingly fast. I wonder how much faster this would be, though, if you user view column values rather than getting the field from the doc? I know, you don't want to have to create a view to use it. Just thinking about performance, not the technique as a whole.

Comment From Bruce Perry

Bruce Perry — Tue, 18 Apr 2006 08:20:56 PM -0700

I've tried this with fairly large comments (at least 250K) plus attachments. I won't claim it's perfect, but I haven't seen it fail yet. It's possible these limits might apply to the R5 version. I've no way to test that currently.

This is probably one of those cases where the help is overly cautious. I'd be very interested to see an up-to-date list of what all the internal limits are in Notes.

Comment From Andrea Ercolino

Andrea Ercolino — Sat, 8 Apr 2006 01:48:18 PM -0700

I didn't try it by myself, but we should trust what the Designer Help says about the AppendRTItem method (though in an improper location):

Also note that the AppendRichTextItem method appends only the first 32K of a RichTextItem; the remainder is truncated.

So it's safer to add each comment at the end of the history (leaving it in place), because a 32K comment is a long one, while a 32K history is much shorter than infinite...

Comment From Bruce Perry

Bruce Perry — Mon, 20 Mar 2006 06:02:22 PM -0700

You bring up a good point. I'll have to take a look at that. It may take a few days. I'm in the middle of starting a new project.

Also, I've added Show-n-tell Thursday to the title. It already has that as a Tecnorati tag and a category within the blog.

Comment From Stephan H. Wissel

Stephan H. Wissel — Sun, 19 Mar 2006 04:47:33 AM -0700

Nice piece of code. You should label it for "Show-n-tell Thursday". I ask myself: would it work if you make the HistUpd computed with HistUpd as formula? This way you wouldn't rely on JavaScript (which could be switched off).
stw

Comment From Stephan H. Wissel

Stephan H. Wissel — Wed, 1 Jun 2005 08:45:50 PM -0700

Looks a little like work in progress. Stan is probably right, that the pipelining it the main reason. I think properties are a good choice over parameters if you: a) have good defaults b) your language (LS) doesn't allow you to overload function calls easily, so you end up with A LOT of parameters (e.g. ws.Dialogbox) where you start counting commas.
Seem like time to write a wrapper class around the process chain
stw

Comment From Stan Rogers

Stan Rogers — Wed, 1 Jun 2005 03:08:06 PM -0700

In this case, I think you can lay it all down to the concept of "pipelining". You set up the properties for all of the processing objects in the pipeline, build the "who feeds who" chain, then call Process once on one object in the pipeline and the whole thing gets put into motion. In that case, there wouldn't be a discreet explicit call to the Importer in your code (the DOMParser or Stream makes an implicit call when it's finished doing what it's doing). You could still parameterize the explicit call, I suppose, but you'd still need to set up properties for the implicit (object-to-object) call. That leaves you with both properties and arguments. Which overrides which in an explicit call. It all gets rather messy in a hurry, doesn't it?

Comment From Greg Walrath

Greg Walrath — Thu, 26 May 2005 01:25:55 PM -0700

Have you looked at BartPE?

http://www.nu2.nu/pebuilder/