[snip]
> > Yeah, I don't have neither insert nor delete.
> > I didn't needed it when I made the lib. I though about
it,
> > but couldn't decide how to approach this problem.
>
> So that the number of methods doesn't blow up, I decided to
> have my "get" and "put" methods take a flags argument to
> provide many functions:
>
> forward/reverse
> move/hold
> read(return original value)/ignore(return length)
> scan or replace vs. delete or insert
>
> Last I counted, I have 12 get functions and 10 put
functions
> (all of which can operator on individual elements or a
> string/array of them). The base class will base all of
these
> on 4 primitives (getdelete before/after and insert
> before/after), but most classes will want to override most
of
> it.Watch out not putting too much behavior in a single function
I know. I've been thinking about which way (many methods or a
few with flags) to go for a while. Both have their cons, but
I've decided on fewer methods with flags.
Can you paste some of your code? I'd like to see it.
Let me give you the interface I have for now:
# flag bits
Reverse = 1 # go in reverse rather than forward
Hold = 2 # hold position instead of moving
Ignore = 4 # get: return length scanned rather than value
Read = 4 # put: return original value rather than length
Delete = 8 # get: delete value retrieved
Insert = 8 # put: insert rather than replace
Next = 0
Prev = Reverse
After = Hold # don't increment position like Next
Before = Reverse|Hold
def get(flags=0,length=nil)
# get(Next) # get next element (like getc)
# get(Next,2) # get next 2 elements (like read)
# get(After) # get an element after (like getc+ungetc)
# get(Next,"\n") # get next elements ending in "\n" (like gets)
# get(Next|Delete) # delete and return next element
# get(Next|Ignore,4) # skip next 4 elements (like seek)
def put(flags,value)
# put(Next,"X"[0]) # put next element (like putc)
# put(Next,"hello") # put next string of elements (like write)
# put(Next|Insert," world") # insert rather than replace
# put(Next|Read,"bye") # read what "bye" is replacing
def position(mark=true,&code)
# p = position() # get position for setting later
# p = position(false) # get position for observe only
# match = position { get(Next,5)=="hello" } # back if mismatch
# the above is great for parsing
def position=(p,mark=true)
# position=(p) # set position (you can still set to p later)
# position=(p,false) # set position and discard p
def unposition(p)
# unposition(p) # discard p
def position?(p=nil)
# position?(p) # is this a valid position to set to?
# position? # are there any valid positions to set to?
After looking at your stuff, I think I may add some other
routines:
def put_to(p,flags,value)
position { position=p; ret = put(flags,value); false }
ret
end
def get_from(p,flags,length)
position { position=p; ret = get(flags,value); false }
ret
end
def copy_from(p,gflags,pflags,length)
gflags &= ~Ignore
position { position=p; v = get(gflags,length); false }
put(pflags,v)
end
def copy_to(p,gflags,pflags,length)
gflags &= ~Ignore
v = get(gflags,length)
position { position=p; ret = put(pflags,v); false }
put(pflags,ret)
end
With the above routines, you can really see where having flags
rather than separate routines becomes very handy. Without it,
there would be too many variations.
ยทยทยท
--- Simon Strandgaard <neoneye@gmail.com> wrote:
On 4/28/05, Eric Mahurin <eric_mahurin@yahoo.com> wrote:
> --- Simon Strandgaard <neoneye@gmail.com> wrote:
__________________________________________________
Do You Yahoo!?
Tired of spam? Yahoo! Mail has the best spam protection around