@Formula-Befehle in Lotus Script abbilden

[TMC]

@Trim

Code

Function atTrim(src, Byval options As Integer)
' src is either a string, or an array of strings.
' options is a set of bit flags corresponding to the constants defined above.  If the ATTRIM_TAB flag is set,
' we will treat tabs as whitespace, replacing them with spaces.  If ATTRIM_NEWLINE is set, newlines will
' be treated as whitespace.  And if ATTRIM_KEEP_NULL is set, null elements will not be removed from the
' array.
   Dim cc$, result$, i&, pos&
   If Isarray(src) Then
 ' recursively process each array element.
      Dim lim%
      lim = Lbound(src)
      Redim retval(lim To Ubound(src)) As String
      pos = lim
      For i = Lbound(src) To Ubound(src)
         result = atTrim(src(i), options)
         If result <> "" Or (options And ATTRIM_KEEP_NULL) Then
            retval(pos) = result
            pos = pos + 1
         End If
      Next
      Redim Preserve retval(lim To max(lim, pos-1))
      atTrim = retval
   Else
      Dim state%, whitespace%
      For i = 1 To Len(src)
         cc = Mid(src, i, 1)
' The string is scanned with a state machine.
'  State 0 means we have not yet encountered a non-whitespace character.
'  State 1 means the last character was non-whitespace.
'  State 2 means the last character was whitespace but there have been some non-whitespace.
         If (cc = " ") Then
            whitespace = True
         Elseif cc = Chr$(9) Then
            whitespace = (options And ATTRIM_TAB)
         Elseif cc = Chr$(10) Or cc = Chr$(13) Then
            whitespace = (options And ATTRIM_NEWLINE)
         Else
            whitespace = False
         End If
         Select Case state
         Case 0:
            If whitespace Then
            Else
               result = cc
               state = 1
            End If
         Case 1:
            If whitespace Then
               state = 2
            Else
               result = result + cc
            End If
         Case Else:
            If whitespace Then
            Else
               result = result + " " + cc
               state = 1
            End If
         End Select
      Next
      atTrim = result
   End If ' src is an array.
End Function

[TMC]

@EasyWord

Watt issn das? Poste es trotzem mal  

Function EasyWord(Byval Source$, Byval Seekk$, Byval pos%) As String
   ' source: a string from which a word is to be extracted.
   ' Seekk: a string containing the character used as word divisions.
   ' pos: which word out of 'source' you want. positive counts frol left to right; negative from right to left (e.g. -1 returns last word). 0 is illegal.
   Dim cpos&, tmp$
   If Pos > 0 Then
      ' if they've asked for other than word 1, throw away all prior to the pos-1st occurrence.
      If pos > 1 Then Source = Strright(Source, Seekk, 0, pos-1)
      cpos = Instr(Source, Seekk)
      ' if the search string occurs again, return all to the left of the search string. Else return entire string.
      If cpos = 0 Then
         EasyWord = Source
      Else
         EasyWord = Left(Source, cpos)
      End If
   Else
      If pos < -1 Then Source = Strleftback(Source, Seekk, 0, 1-pos)
      
      EasyWord = Strrightback(Source, Seekk)
      If EasyWord = "" And Source <> "" Then EasyWord = Source
   End If
End Function

[TMC]

@Begins

Code

Function atBegins(Byval a$, b)
   If Isarray(b) Then
      Dim i%
      For i = Lbound(b) To Ubound(b)
         If atBegins(a, b(i)) Then
            atBegins = True
            Exit Function
         End If
      Next
   Else
      atBegins = (Left(a, Len(b)) = b)
   End If
End Function

[TMC]

@Word

Code

Function Word(Byval source$, Byval delims$, Byval wordnum%) As String
   ' source: a string from which a word is to be extracted.
   ' delims: a string containing one or more characters used as word divisions. Unlike EasyWord,
   '   this may contain multiple single-character delimiters.
   ' wordnum: which word out of 'source' you want. positive counts frol left to right; negative from right to left (e.g. -1 returns last word). 0 is illegal.
   Dim pos&, tmppos&, lastpos&, i&
   If wordnum > 0 Then
      pos = 1
      Do Until wordnum = 0 Or pos = 0
         lastpos = pos
         pos = 1
         For i = 1 To Len(delims)
            tmppos = Instr(pos, source, Mid$(delims, i, 1))
            If tmppos > 0 And tmppos < pos Then pos = tmppos+1
         Next
         wordnum = wordnum - 1
      Loop
      If pos = 1 Then
         word = Mid$(source, lastpos)
      Else
         word = Mid$(source, lastpos, pos-lastpos-1)
      End If
   Elseif wordnum < 0 Then
      Dim tmpstr$, remst$, laststr$
      remst = source
      Do Until wordnum = 0
         laststr = remst
         remst = ""
         For i = 1 To Len(delims)
            tmpstr = Strleftback(laststr, Mid$(delims, i, 1))
            If Len(tmpstr) > Len(remst) Then remst = tmpstr
         Next
         wordnum = wordnum + 1
      Loop
      pos = Len(laststr) - Len(remst)
      If pos > 0 Then Word = Strright(laststr, pos)
   End If
End Function

[TMC]

So :-)

Nun habe ich mal alles gepostet was so rumlag.....  


Saubere Dokumentation: Da stimme ich voll und ganz mit Euch überein !!!

Diskussions-Stuff haben wir ja erst mal  

TMC

[koehlerbv]

Ich hau jetzt erstmal alle Functions rein die ich so finde als Diskussionsbasis :-)

TMC, mach' das bitte nicht - das Zeugs ist bis jetzt fast alles gruselig. Und im Web gibt es noch viel, viel mehr davon. Lass uns ein ordentliches projekt aufsetzen und nicht jeden Schrott hier noch einmal veröffentlichen.
Und auf jeden Fall nicht nur auf @functions begrenzen, sondern "Nützliche Funktionen" als Überschrift setzen.

Eigentlich sollte vorher das Projekt "ErrorHandling" abgeschlossen werden, dann was nützen uns jetzt weitere functions ohne ein AtNotes-gerechtes ErrorHandling ?  ;-)

Bernhard

[TMC]

TMC, mach' das bitte nicht - das Zeugs ist bis jetzt fast alles gruselig.

Sorry, dem war ich mir nicht ganz bewußt.Viel mehr war ich der Meinung, zu 90% läßt sich das nutzen.

Lass uns ein ordentliches projekt aufsetzen und nicht jeden Schrott hier noch einmal veröffentlichen.

Na ja, da stellt sich halt die Frage "Wo fängt man an", "wo hört man auf".
Daher erschien es mir eigentlich sinnvoll, das ganze auf Umsetzungen von @Formulas einzugrenzen.

TMC

[koehlerbv]

Na ja, da stellt sich halt die Frage "Wo fängt man an", "wo hört man auf".
Daher erschien es mir eigentlich sinnvoll, das ganze auf Umsetzungen von @Formulas einzugrenzen.

Hm, ich würde hier eher auf eine AtNotes-typische (also qualitativ hochwertige) Sammlung nützlicher, völlig applikationsunabhängiger Routinen setzen. @functions hat man i.d.R. leicht via Evaluate im Griff - oft aber zäh in der Codierung - pure LotusScript ist pflegeleichter. Aber bei weitem nicht jede @function ist für sowas interessant.

Das ganze Projekt wäre aber mit Vorsicht zu geniessen: Das ErrorHandling habe ich ja schon angesprochen, ausserdem bietet es sich sehr häufig an, von einer Funktion auf eine andere Bezug zu nehmen (sowas glaube ich vorhin auch in einer von Deinen gefundenen Routinen gesehen zu haben). Da wird dann auch die Einbindung interessant: Entweder "alles oder nix" oder "Jede Routine für sich alleine" ...

Und die Schreibe braucht natürlich auch einen Standard (wobei ich hier immer die mir als "Budapester Notation" bekannte bevorzuge) - sonst ist das schwer nachvollziebar / pflegbar.

Schauen wir mal, was daraus wird ;-)

Bernhard

[Axel_Janssen]

TMC: tolle Arbeit.

Stimme mit Bernhard darin überein, dass man das weiterfassen sollte als @functions.

Eine wirklich gute Sammlung gibt es hier: http://www.openntf.org/projects/codebin/codebin.nsf/CodeByDate!OpenView
(falls ihr das nicht schon sowieso wisst).

Die Herausforderung ist nur die Klassifizierung. Wenn sich hierfür Leute finden würden...
Mir fällt adhoc ein:
- String-Funktionen
- Datums-Funktionen (Anton Tauscher hierzu nicht schlecht und von mir von Zeit zu Zeit geplündert).
- Validierungsfunktionen (fangen schon die Überschneidungen mit String an)

Wenn ihr das macht, bau ich ein schneller-als-der-Blitz Java-Swing Interface.
Suche:
- links eine Baumstruktur wie z.B. im Windows-Explorer.
- Beschreibungen können per Volltext durchsucht werden

Persistenz:
- Daten können in LoNo, xml, rdbms abgelegt werden

Handhabung:
- kopieren des codes über 1 Button-Click in die Zwischenablage.

Zusammenarbeit
- können meinen ungeborenen Tomcat-Server im Internet als zentrales, zugriffsgeschütztes Repository verwenden, mit dem die Clients neue code -Schnippsel replizieren. Die Alternative wäre P2P. Kann aber nicht absehen, wie aufwendig das ist.
 
... denke darüber schon länger nach.

[koehlerbv]

Axel, die Sache nimmt Gestalt an ;-)
Wir sollten uns aber zunächst einen Plan aufmalen: Was, wie, Testverfahren, (nicht) erlaubte Abhängigkeiten.
Und wenn Du dann so ein Tool beisteuern könntest ... Das wird wohl was werden !

Eine gute Nacht wünscht
Bernhard

[Axel_Janssen]

o.k. hiers asci-gui prototype  

****************************************************
SmartIcons: Speichern | Beenden | Copy-Code                              *
****************************************************
* Nav-Baum             *     Kategorien: gewählte Kats in Nav
*  Schachtelung       *    
* 1-4 Oberkat.         *     Name: Name
* pro Eintrag            *    
* (Einträge mit          *    Beschreibung
* 1 Oberkat. mgl.     *     Beschreibungsinhalt
* aber auch mit 4     *
*                              *     Code:
*                              *     if x then x end if
*                              *
*                              *
*                              *
*                              *
********************************************************

Muss aber dazu sagen, dass ich bis Weihnachten schon so ein ziemlich volles Programm habe.

So schwierig ist das nicht zu programmieren (4-6 Tage, dann dürfte schon was brauchbares da sein). Problem ist nur die 4-6 Tage zu haben.

Falls der Tomcat nicht da ist (hohe Wahrscheinlichkeit) geht die Replizierung von neuen Einträgen auch über einen halbautomatisierten Prozess wo per email xml-Dateien als Attachment ausgetauscht werden.

Gruß Axel

[eknori]

ihr wisst schon, daß es bereits so ein Projekt gibt ??

http://www.atnotes.de/index.php?board=11;action=display;threadid=3173

[Axel_Janssen]

... da sind sicher einige gute Ideen drin.

Ich bin wg Vorbereitung auf IBM.486-certi (Unified Modelling Language und Unified Process) leicht ideologisiert

(geh mal eben 1 von den 3 Krawatten suchen)


Muß nun knallhart bemerken, dass in diesem Projekt einfach ein zielführender Vorgehensprozess fehlte, so dass ein fassbares Ergebnis herauskam.

Poste heute noch Vorschläge zu einem möglichst simplen und zielführenden Vorgehen. Keine Angst: Verzichte auf Theoretisiererei.

[Semeaphoros]

<Fun>

Was? 486er Zertifizierung? ist das nicht ein paar Jahre zu spät? Ich denke, wir sind unterdessen bei Pentium "Tettares" (4) angelangt und ich warte darauf, dass es bald einmal einen Pentium "Pente" (5) geben wird      


[soviel übrigens nebenbei auch zu der Behauptung von Intel, das Pentium ein Phantasiename sei ..... wers glaubt ..... ]

</Fun>

[Axel_Janssen]

O.k. Unified Prozess (in Folge UP) ist ein iterativer, modularer Prozess mit Phasen.

Phasen sind: Konzeptualisierung, Entwurf, Konstruktion, Übergang

Modular heisst: Es gibt sehr viele Workflows, Planungsartefakte, etc.. Man benutzt aber nur, was man braucht.

iterativ heisst: Projekt wird in Iterationen (2 Wochen pro Iteration) abgewickelt. Vereinfachend gesprochen macht man in jeder Iteration alle Phasen. Die Konzeptualisierung ist also nicht unbedingt mit Iteration2 abgeschlossen. Vielleicht fällt uns beim Übergang noch Fehler in der Konzeptualisierung auf. Dann gibt es halt zu Anfang von Iteration26 eine neue Konzeptualisierungsphase.
Ich finde das zeitgemäss. In Zeiten wo unsere Kleinen immer in diesem Piesa-Test durchfallen, unsere Grossen Geld ausgeben, was sie gar nicht haben und unsere Mittleren als para-terroristische Chaotentruppen mit Krawatten SAP säuselnd in mittelständische Betriebe einfallen, kann man nicht erwarten, dass eine Konzeptualisierung irgendwann solide wie ein Fels ist.

Für die Konzeptualisierung benötigen wir ein Visionsdokument. Dort soll aufgeführt werden, was die stakeholder (=user) (= wir)  von dem System erwarten.

Vision, draft1
Introduction
Wir stellen uns ein code-repository für wiederkehrende Funktionalitäten im Rahmen von LotusDomino Programmierung vor.
Positioning
Business Opportunity:
less wurk, more fun

Problem Statement:
Bisherige code repositories sind meist Insellösungen von jedem selber. Die öffentlichen Repositories im Internet sind nicht so gut durchsuchbar.

Stakeholder description
User:
Leute, die Software Projekte mit LoNo machen
Motivation: wollen nicht so viel denken und tippen wollen und stattdessen lieber wiederkehrende Funktionalitäten aus dem Repository ziehen.

Product Overview

Summary of System Features
Die Funktionen sollen
- leicht wiederauffindbar sein (Kategorisierung, Volltextsuche über Beschreibgung)
- mit möglichst wenig Handgriffen zu kopieren sein
- die Funktionalitäten* sollen replizierbar sein
(dh in einem (semi-)automatischen Prozess soll stakeholderA von stakeholderB alle neue Funktionen* seit der letzten Replizierung anfordern können).



Gruss Axel

* um Begriffsverwirrungen für dieses Projekt (hier hat der Autor z.B. die Begriffe  Funktionen und Funktionalitäten nicht vernünftig abgegrenzt. Sind es Synonyme. Meinen sie was verschiedenes. who knows   UP schlägt hierfür ein Projekt-Glossar vor.

[Semeaphoros]

Räusper


Piesa-Test durchfallen

[Axel_Janssen]

adelante, some brain storming, wer Spass hat soll posten:

Vorschläge:
- wiederverwendbare code-Schnippsel werden als sogenannte code-Dokumente (Datenstruktur) abgelegt.
Diese enthalten:
- eindeutige ID
- Kategorisierung
- Autor
- Datum der Erstellung
- Version
- Beschreibung
- Beschreibung der Verwendung
- code selbst
- andere Funktionen, die sie nutzen*

* Erläuterung:
manchmal ist es sinnvoll betimmte code-Bestandteile des codes von code Dokumenten in eigene Funktionen (und somit eigene code-Dokumente) auszulagern. Etwa, damit eine solche auf einem niedrigeren Level angesiedelte Funktionalität von 2 unterschiedlichen code-Dokumenten auf einem höheren Level benutzt werden. Die ids der code-Dokumente eines niedrigeren Levels müssen in code Dokumenten des höheren Levels eingetragen sein.

[TMC]

Hi,

nachdem ich nun eine Nacht darüber geschlafen habe sehe ich es auch ähnlich wie Ihr es seht:
 - nicht nur auf @Functions einschränken
 - saubere Tests
 - einheitlicher Standard
 - auf einer strukturierten Plattform sauber abbilden (*wink zu Axel*  )
 - Angaben Autor, Datum, Version, etc. (wie von Axel gelistet), zusätzliche Angaben ob/wie das Script getestet wurde
 - nur coole Codes aufnehmen, keine 0815 Einzeiler

TMC

[eknori]

stellt sich mir die Frage : "Was sind coole Codes ? "

[Semeaphoros]

Vielleicht so:
Schneide den Code aus ("Cut"), bringe ihn in den Kühlschrank, lasse ihn eine Weile drin, wenn Du ihn rausnimmst, ist er bestimmt cool. Ob Du ihn dann aufs Brot streichen könntest ("Paste"), weiss ich nicht.

ich ducke mich jetzt gleich wegen des Konjunktivs