AltME groups: search

BrainH asked: Didn't know you could put the /compare index in a block. 
Can you specify more than one index?

Sunanda says: Yes you can:
sort/skip/compare s 4 [1 2 4 3]
== [1 2 8 a 1 2 6 b 1 2 7 c]


That's great but can you do that with a block of blocks of  data....

example: 
s: [
	[1 2 8 a]
	[1 2 6 b] 
	[1 2 7 c]]
]

ok, one last one for my rusty rebol

FINDing the index of all occurences of an integer in a series ie:
blk: [ 239 4545 23 655 23 656[
search for 23 and return [3 5]

(not using foreach)

There must be a way.

An index is a symbol that represents some value. What I need is to 
add some metadata to that index, and make that searchable.

the goal is a blazing key/value store that's as fast as pulling by 
index
:)

I'm comparing to his feach, which was faster... but if I just returned 
the index, it would be faster still (no copy/part).

Henrik, can you post some code that will make a series reference 
that is past the end of a series? I'm having trouble making one that 
works consistently, and neither your INDEX? method or EMPTY? will 
work. REBGL keeps adjusting the index returned by INDEX?.

In R3 they stay consistent, and there is an action PAST? to tell 
whether an index is past the end.
>> b: next a: "a"
== ""
>> remove a
== ""
>> index? b
== 2  ; not adjusted
>> past? b
== true


In R2 I don't even see how to write this in mezzanine without temporarily 
appending something on the end of the series (a single element will 
do) and seeing if the index adjusts, then removing what you appended. 
Like this:
>> b: next next next a: "abc"
== ""
>> clear a
== ""
>> also (index? b) < (append b "1" index? b) clear back tail b
== true  ; past end
>> b: ""
== ""
>> also (index? b) < (append b "1" index? b) clear back tail b

== false  ; not past end, but Henrik's method, and EMPTY? will both 
return true.

Here's the source to the backport:
past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series!] ; gob! port!
][
	also (index? :series) < (insert tail :series "1" index? :series)
		clear back tail :series  ; Undo the modification
]

; Note: Native in R3, and non-modifying. No ports because you can't 
undo the

; insert. INDEX? doesn't stay consistent with past-tail references 
in R2.

You are also removing an element before the index, but not from the 
beginning. Apparently clearing from somewhere other then the beginning 
of the series breaks the auto-adjusting (which shouldn't be happening 
anyways). PAST? works the same either way.

past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series! gob! port!]
][
	(index? :series) = (index? back :series)
]

; Note: INDEX? doesn't stay consistent with past-tail references 
in R2.

correction:

past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series! gob! port!]
][
	and~ not same? head? :series :series
		(index? :series) = (index? back :series)
]

; Note: INDEX? doesn't stay consistent with past-tail references 
in R2.

Yet another variant:

past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series! gob! port!]
][
	and~ (index? :series) = (length? head :series)
		not same? tail? :series :series
]

; Note: INDEX? doesn't stay consistent with past-tail references 
in R2.

past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series! gob! port!]
][
	and~ (index? :series) = (length? head :series)
		not same? tail :series :series
]

; Note: INDEX? doesn't stay consistent with past-tail references 
in R2.

Simplification:

past?: func [
	"Returns TRUE if a series index is past its tail."
	series [series! gob! port!]
][
	not same? :series skip :series 0
]

; Note: INDEX? doesn't stay consistent with past-tail references 
in R2.

But because of that, the PAST? function for R2 needs to work whether 
the index auto-adjusts or not. So before you submit another version, 
test it against past-tail references with auto-adjusting indexes. 
If it works then, it works.

BTW, "returns true if a series index is past its tail" mixes different 
datatypes - series index is integer, while tail is a series, so, 
my opinion is, that the shorter wording is less misleading

(comparing series index - an integer, to series tail - a series)

It's not misleading without the auto--adjustment. With the auto-adjustment 
a past-tail index will auto-adjust, which should be mentioned somehow.

OK, nevermind, I do not want the text to be longer, a "series is 
past its tail" looks better to me, than any reference to series index

, and it relates to the problem better, since in the case below:

>> b
== ** Script Error: Out of range or past end


what is past tail is just the series not any "series index", which 
should be an integer value, and as such it cannot be "past tail"

Is this a bug?

>> o: construct [ a: true b: yes c: yes ]
>> probe o
make object! [
    a: true
    b: 'yes
    c: 'yes
]


http://www.rebolforum.com/index.cgi?f=printtopic&topicnumber=47&archiveflag=new

as usually, all datatypes would need to support this extended format, 
but since it would be managed directly within the native datatype 
handling it would be MUCH faster than if we tried to build some dialect 
for it in REBOL.  especially since the native has much more direct 
access to things like same?, and internal states like series index.

Maxim, we can't extend the existing serialized form to represent 
everything in memory, because binding, cycles and DAGs aren't representable 
without some kind of reference index. So even rebin wouldn't do, 
we'd need something like RIF.

In effect you've created an index

Or you can say I created an index and the query system with two function 
calls.

Here's the R2 version:
extract: func [
	"Extracts a value from a series at regular intervals."
	[catch]
	series [series!]
	width [integer!] "Size of each entry (the skip)"
	/index "Extract from an offset position"
	pos "The position" [number! logic! block!]
	/default "Use a default value instead of none"

 value "The value to use (will be called each time if a function)"

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The buffer series (modified)"
	/local len val
][

 if zero? width [return any [output make series 0]]  ; To avoid an 
 infinite loop
	len: either positive? width [  ; Length to preallocate
		divide length? series width  ; Forward loop, use length
	][

  divide index? series negate width  ; Backward loop, use position
	]
	unless index [pos: 1]
	either block? pos [

  if empty? pos [return any [output make series 0]] ; Shortcut return
		parse pos [some [number! | logic! | set pos skip (

   throw-error 'script 'expect-set reduce [[number! logic!] type? get/any 
   'pos]
		)]]
		unless into [output: make series len * length? pos]
		if all [not default any-string? output] [value: copy ""]
		; R2 PARSE doesn't work well for binary!, so spoof a string!.
		if binary? series [series: as-string series]
		forskip series width [forall pos [
			if none? set/any 'val pick series pos/1 [set/any 'val value]
			output: insert/only output get/any 'val
		]]
	][
		unless into [output: make series len]
		if all [not default any-string? output] [value: copy ""]
		; R2 PARSE doesn't work well for binary!, so spoof a string!.
		if binary? series [series: as-string series]
		forskip series width [
			if none? set/any 'val pick series pos [set/any 'val value]
			output: insert/only output get/any 'val
		]
	]
	either into [output] [head output]
]

Here's the R3 version:
extract: func [
	"Extracts a value from a series at regular intervals."
	series [series!]
	width [integer!] "Size of each entry (the skip)"
	/index "Extract from an offset position"
	pos "The position(s)" [number! logic! block!]
	/default "Use a default value instead of none"

 value "The value to use (will be called each time if a function)"

 /into "Insert into a buffer instead (returns position after insert)"
	output [series!] "The buffer series (modified)"
	/local len val
][  ; Default value is "" for any-string! output

 if zero? width [return any [output make series 0]]  ; To avoid an 
 infinite loop
	len: either positive? width [  ; Length to preallocate
		divide length? series width  ; Forward loop, use length
	][

  divide index? series negate width  ; Backward loop, use position
	]
	unless index [pos: 1]
	either block? pos [

  unless parse pos [some [number! | logic!]] [cause-error 'Script 'invalid-arg 
  reduce [pos]]
		unless output [output: make series len * length? pos]
		if all [not default any-string? output] [value: copy ""]
		forskip series width [forall pos [
			if none? set/any 'val pick series pos/1 [set/any 'val value]
			output: insert/only output :val
		]]
	][
		unless output [output: make series len]
		if all [not default any-string? output] [value: copy ""]
		forskip series width [
			if none? set/any 'val pick series pos [set/any 'val value]
			output: insert/only output :val
		]
	]
	either into [output] [head output]
]

My first thought was to introduce a new datatype (like a "lit-integer!" 
(eg. '1) or an "index-integer!" (eg. @1), but it still means there 
will exist a datatype which, in a path, does not SELECT like other 
types, but is interpreted as a direct index PICKer.

So now I think there could be some "escape" path notation which changes 
the PICK-type functionality of integer path members into the SELECT 
type (which all the other datatypes have by default).

eg.  values/^1/dos/new   <-- The ^ causes the path to consider the 
following integer 1 as a series member to be SELECTed like other 
datatypes, instead of the PICK special treatment.

why do you say blk/'1/is confusing?  it means use the integer litterally, 
not as an index.

or should I say, not as an ordinal index

you guys didn't solve the "how do we use an integer as a key instead 
of an index"


this is a GAPING hole in path evaluation.  using integers isn't some 
fancy side datatype.


we are not adding a new datatype, its not a complex system like using 
parens (which is also very slow) and it doesn't require advanced 
binding tricks.

you guys didn't solve the "how do we use an integer as a key instead 
of an index" - you *can* use integer as a key without using it as 
an index, if you like. Nevertheless, the path-access does not work 
like that. You should either get used to it, or use a different access 
method, that is all. Anyway, you have got no right to call it a "GAPING 
hole in the path evaluation", taking into account, that it is by 
design. The fact, that your design preferences differ is irrelevant.

the path evaluation is responsible for what it does with any type. 
 just like a parser.   for path notation is only serves the purpose 
of identifying a label vs an index (in the case of integer results 
specifically)

move: make function! [[
    "Move a value or span of values in a series."
    source [series!] "Source series"
    offset [integer!] "Offset to move by, or index to move to"
    /part "Move part of a series"
    length [integer!] "The length of the part to move"
    /skip "Treat the series as records of fixed size"
    size [integer!] "Size of each record"
    /to {Move to an index relative to the head of the series}
][
    unless length [length: 1]
    if skip [
        offset: offset * size: max 1 size
        length: length * size
    ]
    part: take/part source length
    insert either to [at head source offset] [
        system/words/skip source offset
    ] part
]]

By the way, when you have 1-based indexing, 0 is a negative index 
:)

yep... not the best for the math in index calculations.... hehehe 
but much more human readable for code and human interaction, so I 
still prefer one indexing after 9 years... even if the techy in me 
sometimes lets out a little <sigh>  in trying to get to the proper 
start/end of complex series extractions  hehehe

Maxim, once you have 1-based indexing (which we are stuck with for 
historical reasons), then having 0 be negative *is* the best for 
math calculations. That way you can count on offset = index - base.

but functions like insert are a bit simpler to use with 0 based, 
since a length is used as the value past an item in a series not 
the last character in it.


they both have advantages.   but trying to explain to someone that 
an index of 0 moves backwards isn't very obvious to promote as a 
feature ;-)


I'd have trouble justifying this to my kid which is learning to do 
math  :-D

/skip is a length, not a index or an offset. I'm not sure what effect 
/skip past start should have.

So actually, vectors are only for storing index purpose (to save 
memory).
Because Carl has only that need.
Hum...
He could use binary series instead, if it's his only one need.

Vectors without maths are only binary streams with less capabilties.

i use bniaries to store large index since several years with R2

Here's the R2-Forward version:

first+: funco [
	{Return FIRST of series, and increment the series index.}
	[catch]

 'word [word! paren!] "Word must be a series."  ; paren! added for 
 R2
][

 ; Workaround for R3 change in lit-word! parameters with paren! arguments
	if paren? :word [set/any 'word do :word] 
	throw-on-error [also pick get word 1 set word next get word]
]

there is a better way to write that request: AT should support block 
directly as index.

But those are supposing you know the index length.   I was hoping 
to avoid that with my request.

i think he wants AT working like COPY/PART (the index could be an 
integer or a serie aswell)

Well, if the index is a series offset, even a calculated one, then 
you can already have a reference to that offset without the AT.

If we don't have the "chaining"  behavior with reduce/into, then 
we will lost some speed in loops (because of the need to update the 
index of the serie separatly after each iteration).

Or in my case archived and taken out of the index, Maxim :(

Here is a great example code using GrandCentral: "DispatchWebServer"

from the description: "A web server that uses one queue per HTTP 
connection. Supports HTTP pipelining and on-the-fly compression. 
Also shows use of dispatch-style signal and vnode event handling."

https://developer.apple.com/snowleopard/library/samplecode/DispatchWebServer/index.html
(ADC account needed)
Whoever is doing R3 on OS X, should have a look 8-)

as long as the index can be used as such.  using an object for the 
index should raise an error.

using an object for the index should raise an error
 - you mean e.g. poke 4 index, when the index is "out"?

sorry, I mean poke block 4 index

Ladislav, my point was that if bounds matter, INDEX? *not* generating 
an error (or changing its results) for an out-of-bounds index *is 
itself an error*. If bounds don't matter (except apparently for POKE), 
then INDEX? not changing its behavior is fine.

my experience tells: it is better to be able to find out what the 
value of INDEX actually is (even for debugging), than to obtain an 
error, which does not tell me where I actually am

that depends on the quantity of marking bits, if you have only one 
marking bit, you can just detect cycle, if you have 32 bits, you 
can detect the index

Ladislav, the cyclic structures above are not the same structure, 
but the results would need to be considered EQUAL?. Unless we declare 
that cyclic structures need to have the same structure to be declared 
equal - then we can use a stack of ref/index for the structure detection.

these index issues - there are simply too many variants of equality 
- the Equal-state? comparison is certainly unrelated to any of the 
currently proposed hierarchy levels

As for the JIT, I could write the compiler in REBOL and generate 
the intermediate code of the JIT, then pass that intermediate code 
to the JIT with a command. The JIT would then generate a function, 
add it to its list, and return the list index as an integer. That 
integer can be  used to create a new command!, which RX_Call can 
dispatch to the internal JITed function.

3:1 for current index based method to 'remove ...

Only to say i don't see the interest to have 'remove based on an 
index method.

Because doing that:
parse "..." [ here:  "b"  remove here ]

Is nothing less than doing like currently:
parse "..." [here: "b" (remove here)]

I don't see any gain. 
Oh sorry, we don't have the ( )
Victory !!!!

What is the outcome of Steeve's proposals? Carl said something about 
inlining of REMOVE. Will it change from the index based aproach, 
which is now implemented?

Then let's have REMOVE 1, to make Steeve happy :-) He is right that 
index aproach still can work in terms of storing a position into 
variable and doing REBOL level remove in parens ...

i like tht way to resume parse action car "Match then Action"  then 
the problem is when you match somthing then you when your action 
not to impact on the match thing but on the following  or preciding 
thing. The index system is the main problem in my opinion:  where 
i am ? what does i store  and until what point ?  i'm before or after 
my match ? and if my match is not  given in the right way how can 
i be sure my match tags are not taken inverted and that my action 
system will not freak out ?


Programming in parse gives you so many "asks" to care about that 
you are fast lost. But i'm agree the  result of parse rules in general 
once understoud (if it's any time the case ) is easy and beauty full.

what i have real difficulties to figure out in parse is the index 
system... I have a problem to see where i'm  and what my actions 
is doing.  do i "store index match then action" or do i  "match store 
then action" ? And if you add to that the sub rules i'm like completly 
lost. Cause in some cases sub rules can trigger their own particular 
special only for them actions ...

A serialized serie keeps his index, not bad -)

That could perhaps be useful. Generally there has been some level 
of index concurrency control with multiple series missing in R2, 
like being able to do a FORALL on multiple series simultaneously. 
I can't remember if R3 solves any of that, because it's been discussed 
quite a long time ago.

Maybe Cygwin could be a use as a console for REBOL under Windows? 
Libraries like this could be used then:
http://www.astro.caltech.edu/~mcs/tecla/index.html


I can't imagine a serious developer would be ok with the default 
Win console and no history and such.

Have Bitset! some limit?  May it be used as bitmap index for some 
larger set?

Thanks for analysis Kcollins! Maxim the question was if Bitmap may 
be used as searchable bitmap index into dataset (key-value, index-value 
in this case) all this in searching of holly grail what is named 
RIF in Rebol :). The answer is yes if you would use max 16 M of indexes. 
The merit is using somehow compressed format. Oher info in Wikipedia 
bitmap indexes, or Fastbit database (database for very large datasets 
from particle colliders).

how can I remove an entry from a map! in R3? BTW, I use string! (not 
word!) as index here, so I cannot just say:  my-map/my-word: none

SSL

server {
  listen   127.0.0.1:443;
  server_name  secure;
  access_log  /var/log/nginx/secure.access.log;
  error_log  /var/log/nginx/secure.error.log;
  ssl on;
  ssl_certificate /etc/nginx/ssl/server.crt;  
  ssl_certificate_key /etc/nginx/ssl/server.key;  
  location / {
    root   /var/www/secure;
    index  index.html index.htm;
  }
}

LOAD BALACER 
upstream python_servers {
  server 127.0.0.1:8001;
  server 127.0.0.1:8002;
}
server {
  listen   127.0.0.1:8000;
  server_name  proxy;
  access_log  /var/log/nginx/proxy.access.log;
  error_log /var/log/nginx/proxy.error.log;
  location / {
    proxy_pass http://python_servers;
  }
}

--

Both seem logical and if combining ssl + proxy (server part) them 
would work I would get what I need

pekr, why not just specify the index to be an rsp script instead? 
since it seems to be dynamic in the first place?

Pekr: that's in my todo list, I just need to find some free time 
to think more deeply about how to support such feature efficiently.


Btw, I have built a XMLC (XML Compiler) engine inspired by enhydra 
(http://www.enhydra.org/tech/xmlc/index.html) which should fit perfectly 
your needs. It's a working prototype but need some significant work 
to be integrated within Cheyenne, so it's low priority for now.

Maxim your associative datasets are in memory or in disk, are you 
using any index or simply search thru dataset?

http://web.syllable.org/pages/index.html#id-2010-01-02-22-16

ActionScript, which is Flex's programming language is now in #19 
in Tiobe's index.

http://webkit.org/demos/sticky-notes/index.html

I agree that #[...] really makes things easier and cleaner. Performance 
impact is not significant, the overhead is just a string! PICK in 
a block with a static index as argument (that's one of the nice advantage 
of compiling RSP scripts). OTOH, the SAY function has to do a hash 
table lookup to get the right index (so a tiny little bit slower 
than the literal form).

is there any other configuration or something to use databases with 
cheyenne? I configured as it shown in web site but I always get the 
error:

##RSP Script Error: 
	URL  = /
	File = www/index.rsp
	** Access Error : Invalid port spec: odbc://test2
	** Where: do-sql 
	** Near:  [do-sql 'test2 "select * from table" 
__txt 62
] 

my rsp site is:
<%
	print do-sql 'test1 "select top 10 * from sec_log1"
%>

and the httpd.conf file:

databases [
	test1	mysql://[root-:-localhost]/test
	test2	odbc://test
]

--- unix.r.original	2010-05-09 03:22:33.000000000 +0200
+++ unix.r	2010-05-10 00:36:14.000000000 +0200
@@ -5,6 +5,8 @@
 		exists? libc: %libc.so.6
 		exists? libc: %/lib32/libc.so.6
 		exists? libc: %/lib/libc.so.6

+		exists? libc: %/System/Index/lib/libc.so.6  ; GoboLinux package

+		exists? libc: %/system/index/framework/libraries/libc.so.6  ; 
Syllable
 		exists? libc: %/lib/libc.so.5
 	]
 	libc: load/library libc

http://www.owasp.org/index.php/SQL_Injection_Prevention_Cheat_Sheet#Defense_Option_1:_Prepared_Statements_.28Parameterized_Queries.29

http://www.googlefight.com/index.php?lang=en_GB&word1=rebol&word2=less.js

good site to test web sockets http://jwebsocket.org/index.htm

I wrote a very simple ws client protocol, http://rebolforum.com/index.cgi?f=printtopic&topicnumber=47

so if I setup the subdomain to point to www.rebol.com/abc/index.html 
.. then that's what shows.  I want it to display abc.rebol.com/index.html

You can, except you, I think only Philippe Legoff got that far :-) 
BTW, he wrote a few nice articles (french only) on Cheyenne usage: 
http://pl.legoff.free.fr/dotclear/rebol-fondation/index.php/?q=cheyenne

btw, http://equi4.com/starkit/index.htmlis an encapping solution 
for tcl.

i just accidentally saw it mentioned in a rebol blog entry: http://www.rebol.com/cgi-bin/blog.r?view=0375#comments
 :)

This is a small editor with ajax support .. but probably no autosave 
http://remiya.com/htmlbox/index.php/12/demo/ajax-demo.html

I have a problem with cheyenne-r0920-cmd.exe on Windows, when I comment 
database section in my http.cfg it works, when I uncomment it gives 
the following error in chey-pid-9036.log file:


25/1-17:58:14.625-## Error in [uniserve] : On-received call failed 
with error: make object! [
    code: 515
    type: 'access
    id: 'invalid-path
    arg1: "/E/cheyenne/www/centrex//index.rsp"
    arg2: none
    arg3: none
    near: [info? new [
            req/in/target: form file 
            if ext: find/last req/in/target dot [
                req/in/ext: to word! ext 
                req/handler: select service/handlers req/in/ext
            ] 
            if not req/in/file [req/in/file: new] 
            if d?: declined? req [return false]
        ]]
    where: 'throw-on-error
] !


note that there is double slash before index.rsp I don't know why. 
Error happens before I use any do-sql or something. Web page doesn't 
work at all.

Doc: Same error with latest r173 version.

I just put the databases block into webap block, didn't change anything 
in the testapp,

	webapp [
		databases [
			cdr	odbc://sa:[qwe123-:-cdr]
		]
		virtual-root "/testapp"
		root-dir %www/testapp/
		auth "/testapp/login.rsp"
		;debug
	]
error is:
    code: 515
    type: 'access
    id: 'invalid-path
    arg1: {/E/cheyenne-sources/Cheyenne/www/testapp//index.rsp}

Note that the double slash in arg1.

Doc: I found where the bug is:
It is in mod-fastcgi.r file line 65:
new: rejoin [cfg/root-dir req/in/path file]

cfg/root-dir: %www/testapp/
req/in/path: "/"
file: %index.rsp
new: %www/testapp//index.rsp

Offered by:
	TomBon
Task:

 Bindings for OpenDBX. Old R2 style (External Library Interface)  
 or R3 Extension. 
	http://www.linuxnetworks.de/doc/index.php/OpenDBX
Amount:
	$250
Valid until:
	18.07.2010
Terms:
	PayPal 

--------------------------------------------------------------------------------
Task:
	R3 - simplified DLL interface 
	http://rebol.wik.is/Bounties/R3_-_simplified_DLL_interface
Amount:
	$350
Valid until:
	18.07.2010
Terms:
	PayPal

offered by:
	TomBon
Task:

 R3 - Bindings for a KNNL - SOM (Self-organizing map) /Kohonen Network
	http://knnl.sourceforge.net/

	API - http://knnl.sourceforge.net/html/index.html

	Further Readings:
	http://en.wikipedia.org/wiki/Self-organizing_map
	http://www.ifs.tuwien.ac.at/dm/somtoolbox/
	http://accu.org/index.php/journals/1378
	http://www.codeproject.com/KB/graphics/som.aspx

	Alternativ:
	Quick Tutorial on how to construct a SOM.
	Perhaps to create a modul directly in R3?
	http://www.ai-junkie.com/ann/som/som1.html


Amount:
	$350
Valid until:
	01.04.2011
Terms:
	PayPal

Documentation in the code itself using comments, and you structure 
the code for human reading. To any programmer of a language that 
is designed for readability - like REBOL - reading the flow of the 
code is like reading a story. You can understand it immediately.


Reading a literate programming document is like reading a manual 
though, so unless it has story or essay structure it will be difficult 
to understand. Reading the code generated by literate programming 
is like reading a stack of 3.5 index cards that were going to be 
used as research for a story or essay, but were instead just taped 
together at random. The overall structure of the code and every hint 
of the author's intentions are lost.

packet are append to port/data but the index is not moved

so the index is used by ??

The details of the port actor for WRITE are:


   1. Set port/data to WRITE content (binary string) value. (Mainly 
   to keep it GC safe.)

   2. Obtain binary string as specified. The buffer is not copied. This 
   is a low level mechanism.
   3. Determine start position from index.

   4. Determine length from tail-index or from /part if specified.

   5. Set IO-request length and data. Zero the actual field (the length 
   actually transferred).
   6. Call the TCP device with the IO-request
   7. Check for errors

   8. Check for immediate completion. If done, set port/data to NONE.

Alas my index is worse than that for the r3 docs

RDI_NET is the index for the tcp port device

Rebol [
    file: %prot-rif.r
    title: "RIF protocol"
    author: "Pavel"
    rights: 'PD
    date: 13-Aug-2010
    ]

;; Local functions

Append-RIF: func [port [port!] record [binary!] ][


 write/append port/locals/2 to-binary length? head port/locals/1		;index 
 port the end of data file will be beginning of new record

 write/append port/locals/1 record							        ;data port new record 
 into data file


 return shift length? head port/locals/2 -3					        ;number of 
 records 8 bytes per record
]


Get-RIF: func [ port [port!] i [integer!] /local numentry indexpos 
recpos recend value ][


    numentry: shift length? head port/locals/2 -3                    
       ;number of records 8 bytes per record


 if any [i = 0 i > numentry] [return none]                        
    ;numbering starts at 1 ends at file end


 indexpos: multiply subtract i 1 8					                ;compute index 
 offset
	recpos: to-integer read/seek/part port/locals/2 indexpos 8

  either ( (8 * i) = length? head port/locals/2 ) [				;last record 
  special case
		recend: length? head port/locals/1
		][

  recend: to-integer read/seek/part port/locals/2 add indexpos 8 8		;internal 
  record
		]

 return read/seek/part port/locals/1 recpos subtract recend recpos
]

;; Scheme definition
make-scheme [
	name: 'rif
	title: "RIF Protocol"
	spec: make system/standard/port-spec-head []
    awake: none

	actor: [
		open: func [port [port!] /local path ] [
            parse port/spec/ref [thru #":" 0 2 #"/" path:]
            append port/spec compose [path: (to-file path)]
            port/locals: copy []
            either (0 = length? port/locals) [

                append port/locals open/seek rejoin [port/spec/path ".dat"]

                append port/locals open/seek rejoin [port/spec/path ".idx"]
                ][

                port/locals/1 open/seek rejoin [port/spec/path ".dat"]

                port/locals/2 open/seek rejoin [port/spec/path ".idx"]
            ]
        return port
        ]

        close: func [port [port!]] [
            foreach  port port/locals [close port]
        ]

        read: func [port [port!] /seek number [integer!] ] [
            Get-RIF port number
        ]

        write: func [port [port!] record [binary!]] [
            Append-RIF port record
        ]

    ]
]