CopyStructure und LinkedLists

[delikanli_19_82]

hallo leute,

ich habe hier eine konzeptfrage. wenn man jetzt mit pb ein interface-objekt bastelt, so muss ja seine gesamtgröße eindeutig sein. arrays können ja nicht direkt in so ein interface untergebracht werden. kann man dieses problem mit hilfe des copystructure-befehls lösen? und falls ja, wäre das ein guter ausweg, oder doch eher nicht zu empfehlen, da ja die gesamte struktur im speicher kopiert wird. die alte könnte man ja dann mit clearstructure löschen.

falls das nicht geht, dann eine andere frage. gibt es irgendeinen vernünftigen weg, interface-objekte dazu zu bringen, intern arrays aufzunehmen und zu verwalten.

im moment habe ich das problem dadurch umgangen, das ich globale struktur-variablen mit entsprechenden linkedlists und einem id versehen habe. wenn ein objekt-instanz geladen wird, so wird im konstruktur eine interne id-nummer erzeugt und in der globalen struktur-variable ein neuer abschnitt angelegt und dort ebenfalls die id eingetragen. immer wenn ich mit dem instanz-x arbeite, springt dessen methode sicherheitshalber jedesmal per foreach, innerhalb dieser globalen linkedlist an die richtige stelle und erst dann werden die daten ausgewertet bzw. manipuliert.

mfg

kurt

[NicTheQuick]

Redest du von statischen Arrays oder von dynamischen Arrays? Die dynamischen Arrays kannst du doch ganz einfach in eine Structure einbauen, vorausgesetzt du hast ein aktuelles PureBasic.
Mach lieber mal einen kleinen Beispielcode, an dem wir das Problem genau verstehen können.

Danke!

[delikanli_19_82]

der nachfolgende code funktioniert nicht, soll aber sinnesgemäß das wiederspiegeln, was ich mir vorstelle, wie ich es ungefähr haben will:

Code: Alles auswählen

; um bestimmte aufgabenbereiche eines objekts zu gruppieren, bastelle ich mehrere strukturen, die die erwünschten
; bereiche zusammenfassen.

; position und volumn des objekts
Structure objektname_p_sz
 x.l : y.l : w.l : h.l
EndStructure

; hier werden beispielsweise die daten zu einem Abschnitt gesammelt ( dieses beispiel ist fiktiv und soll eine komplexe array-struktur demonstrieren )
Structure objektname_con_ety
 List txt.s()
 List key.s()
 List nbr.l()
EndStructure

; hier werden beispielsweise die daten gesammelt (dynamisch natürlich)
Structure objektname_con
 list value.objektname_con_ety()
EndStructure

; Das Interface
Interface objektname
 methode_a()
 methode_n()
EndInterface

; Die Body-Struktur
Structure objektname_body
 Tbl.l
 Met.l[SizeOf(objektname)/4]
 psz.objektname_p_sz
 ; HIER DAS WAS ICH EIGENTLICH MÖCHTE, EINE STRUKTUR
 ; DIE EINEN DYNAMISCHEN ARRAY (und unter umständen eben
 ; weitere Subarray ) ENTHÄLT.
 con.objektname_con
EndStructure

...

Ich würde gerne eine solche oder ähnliche lösung haben, so das ich arrays in objekte integrieren kann, so das jedes
objekt seine eigene kopie der für ihn vorgesehenen linkedlists hat und damit arbeitet.

mfg

kurt

[delikanli_19_82]

hat sich erledigt. habe eine lösung gefunden

[Deluxe0321]

Code: Alles auswählen

Interface __interface
  SayHello(Text.s)
  AddListElements(Count.i)
  AddArrayElements(Count.i)
  GetListSuff()
  GetArrayStuff()
  GetListElement()
  SetListElement(Element.i)
  GetArrayElement()
  SetArrayElement(Element.i)
  FreeAll()
EndInterface

Structure __listStruc
  A.i
  B.i
  C.i
EndStructure

Structure __arrayStruc
  Text.s
  int.i
EndStructure

Structure __interfaceStruc
  ___procs.i
  __MyListElement.i
  __MyArrayElement.i
  List MyList.__listStruc()
  Array MyArray.__arrayStruc(0)
EndStructure

Procedure _SayHello(*this.__interfaceStruc,Text.s)
  If Text.s
    MessageRequester("Hello",Text.s)
  EndIf
EndProcedure

Procedure _AddListElements(*this.__interfaceStruc,Count.i)
  If Count.i > 0
    For a=0 To Count.i
      AddElement(*this\MyList())
        *this\MyList()\A.i = Random(9999)
        *this\MyList()\B.i = Random(9999)
        *this\MyList()\C.i = Random(9999)
    Next
    ProcedureReturn Count.i
  EndIf
  ProcedureReturn -1
EndProcedure

Procedure _AddArrayElements(*this.__interfaceStruc,Count.i)
  If Count.i > 0
    ReDim *this\MyArray(Count.i)
    For a=0 To Count.i
        For b=0 To Count.i 
          *this\MyArray(a)\Text.s + Chr(65+Random(30))
        Next
        *this\MyArray(a)\int.i = Random(9999)
    Next
    ProcedureReturn Count.i
  EndIf
  ProcedureReturn -1
EndProcedure

Procedure _GetListSuff(*this.__interfaceStruc)
  Static *MyListStatic.__listStruc
  If ListSize(*this\MyList())
    ResetList(*this\MyList())
    SelectElement(*this\MyList(),*this\__MyListElement.i)
    *MyListStatic = *this\MyList()
    ProcedureReturn *MyListStatic
  EndIf
EndProcedure

Procedure _GetArrayStuff(*this.__interfaceStruc)
  Static *MyArrayStatic.__arrayStruc  
  If ArraySize(*this\MyArray())
    *MyArrayStatic = *this\MyArray(*this\__MyArrayElement.i)
    ProcedureReturn *MyArrayStatic
  EndIf
EndProcedure

Procedure _GetListElement(*this.__interfaceStruc)
  ProcedureReturn *this\__MyListElement.i
EndProcedure  

Procedure _SetListElement(*this.__interfaceStruc,Element.i)
  If Element.i > -1 And Element.i < ListSize(*this\MyList())
    *this\__MyListElement.i = Element.i
    ProcedureReturn #True  
  EndIf
EndProcedure  

Procedure _GetArrayElement(*this.__interfaceStruc)
  ProcedureReturn *this\__MyArrayElement.i
EndProcedure  

Procedure _SetArrayElement(*this.__interfaceStruc,Element.i)
  If Element.i > -1 And Element.i < ArraySize(*this\MyArray())
    *this\__MyArrayElement.i = Element.i
    ProcedureReturn #True  
  EndIf
EndProcedure

Procedure _FreeAll(*this.__interfaceStruc)
  If ListSize(*this\MyList())
    ClearList(*this\MyList())  
  EndIf
  
  If ArraySize(*this\MyArray())
    ReDim *this\MyArray(0)  
  EndIf
EndProcedure

Procedure NewMyInterface()
   Protected *this.__interfaceStruc
   
   *this = AllocateMemory(SizeOf(__interfaceStruc))
   If *this
     InitializeStructure(*this, __interfaceStruc)
      *this\__MyArrayElement = -1
      *this\__MyListElement  = -1
      *this\___procs.i = ?_interface_procs_
   EndIf
   
   ProcedureReturn *this  
EndProcedure

DataSection
  _interface_procs_:
  Data.i @_SayHello()
  Data.i @_AddListElements()
  Data.i @_AddArrayElements()
  Data.i @_GetListSuff()
  Data.i @_GetArrayStuff()
  Data.i @_GetListElement()
  Data.i @_SetListElement()
  Data.i @_GetArrayElement()
  Data.i @_SetArrayElement()
  Data.i @_FreeAll()
EndDataSection

;Create 3 "Structured Interfaces"
NewList *this.__interface() 
For a=0 To 3
  AddElement(*this())
  *this() = NewMyInterface()
Next

;We want one element for now
SelectElement(*this(),1)

*myList.__listStruc
*myArray.__arrayStruc

*this()\SayHello("I like Turtels!")

;generate some Elements
*this()\AddArrayElements(100)
*this()\AddListElements(100)


For a=0 To 3
  Debug a
  ;set the Element
  *this()\SetListElement(Random(100))
  
  ;get the stuff
  *myList = *this()\GetListSuff()
  Debug *myList\A.i
  Debug *myList\B.i
  Debug *myList\C.i
  Debug ""
Next

;set the Element
For a=0 To 3
  *this()\SetArrayElement(Random(100))
  
  ;get the stuff
  *myArray = *this()\GetArrayStuff()
  Debug *myArray\int.i
  Debug *myArray\Text.s
  Debug ""
Next

*this()\FreeAll()

KP, ob das dein Problem löst, ich verstehe dich nicht ganz.
Intern kannst du erstellen, kopieren, löschen wie du lustig bist. Trotzdem musst du Angeben mit was gearbeitet werden soll.
Wenn du für Jedes Element deiner "Struktur" ein eigenes Inferface willst, ist das auch kein wirkliches Thema. Einfach erstellen.

Gruß Deluxe0321
Edit: Zu langsam Gut das du eine Lösung für dich gefunden hast.

[bobobo]

aber schlecht dass die hier nicht gepostet worden ist

[delikanli_19_82]

ich habe hier eine lösung gebastelt. bin damit aber nicht ganz zu frieden. eigentlich möchte ich die
struktur mit der linkedlist nicht global deklarieren, sondern in den objekt hineinpacken, so dass es von außen
nicht mehr zugänglich ist und nicht manipuliert werden kann.

Code: Alles auswählen

Structure capi_array_string_struct
  List lst.s()
EndStructure

Global NewList capi_array_string_data.capi_array_string_struct()
Global capi_array_string_pointer.l = 0

Interface capi_array_string
  Add( value.s )
  Index.l( value.l = -1 )
  Count.l()
  Delete( value.l = 0 )
  Value.s( value.l )
  Clear()
EndInterface

Structure capi_array_string_body
  Tbl.l
  Met.l[SizeOf(capi_array_string)/4]
  cnt.l
  ptr.l
  *lst.capi_array_string_struct
EndStructure

Procedure capi_array_string__Add( *this.capi_array_string_body, value.s )
  AddElement( *this\lst\lst() )
  *this\lst\lst() = value
  *this\cnt + 1
EndProcedure

Procedure.l capi_array_string__Index( *this.capi_array_string_body, value.l = -1 )
  If value >= 0 And value < *this\cnt
    SelectElement( *this\lst\lst(), value )
  EndIf
EndProcedure

Procedure.l capi_array_string__Count( *this.capi_array_string_body )
  ProcedureReturn *this\cnt
EndProcedure

Procedure.l capi_array_string__Delete( *this.capi_array_string_body, value.l = 0 )
  If value >= 0 And value < *this\cnt
    DeleteElement( *this\lst\lst(), value )
  EndIf
EndProcedure

Procedure.s capi_array_string__Value( *this.capi_array_string_body, value.l )
  If value >= 0 And value < *this\cnt
    SelectElement( *this\lst\lst(), value )
    ; ***
    ProcedureReturn *this\lst\lst()
  Else
    ProcedureReturn ""
  EndIf
EndProcedure

Procedure capi_array_string__Clear( *this.capi_array_string_body )
  ClearList( *this\lst\lst() )
  ; ***
  *this\cnt = 0
EndProcedure

Procedure capi_array_string ()
  *obj.capi_array_string_body = AllocateMemory(SizeOf(capi_array_string_body))
  If *obj = 0: ProcedureReturn 0 : EndIf ; Memory allocation failed
  *obj\Tbl = *obj + OffsetOf(capi_array_string_body\Met)
  ; ***
  *obj\cnt = 0
  ; ***
  AddElement( capi_array_string_data() )
  ; ***
  *obj\lst = capi_array_string_data()
  ; ***
  capi_array_string_pointer + 1
  ; ***
  *obj\Met[0] = @capi_array_string__Add()
  *obj\Met[1] = @capi_array_string__Index()
  *obj\Met[2] = @capi_array_string__Count()
  *obj\Met[3] = @capi_array_string__Delete()
  *obj\Met[4] = @capi_array_string__Value()
  *obj\Met[5] = @capi_array_string__Clear()
  ; ***
  ProcedureReturn *obj
EndProcedure

test.capi_array_string = capi_array_string()

test\Add( "Hallo" )
test\Add( "Welt" )
test\Add( "Ola" )
test\Add( "Ninja" )

Debug "TEST"
For x = 0 To test\Count() -1
  Debug test\Value(x)  
Next
Debug ""

zwei.capi_array_string = capi_array_string()

zwei\Add( "abc" )
zwei\Add( "def" )

Debug "ZWEI"
For x = 0 To zwei\Count() -1
  Debug zwei\Value(x)  
Next

ich habe versucht mit einer statischen strukturdeklaration innerhabl des constructors das problem zu lösen.
der hat aber den nachteil, das jede instanz, ja logischerweise, die selbe speicherstelle als interne liste
übernehmen. und das macht ja keinen sinn.

weiß jemand einen Rat?

mfg

kurt

[NicTheQuick]

Siehe Deluxe0321.

[delikanli_19_82]

hier eine endgültige version für strings. dieser funktioniert jetzt perfekt. nochmals danke an alle beteiligten. habe nun daraus
noch varianten für long, integer, byte, float, double, word und unicode erstellt.

Code: Alles auswählen

              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Class Interface
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Interface capi_array_string
                Add( value.s )
                Index.l( value.l = -1 )
                Count.l()
                Delete( value.l = 0 )
                ; Das {...} dient als Default, um damit einen ProcedureReturn, statt Manipulation zu bewirken
                Value.s( index.l, value.s = "{ABCDE-EFC32-32321-0323EC-32DEC-123EF}" )
                Clear()
                Sort( nocase.b = #False, increment.b = #True )
                Find.b( value.s, nocase.b = #False )
                Where.l( value.s, nocase.b = #False )
                Min.s()
                Max.s()
                Filter( value.s, nocase.b = #False )
              EndInterface
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Class Body Structure
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Structure capi_array_string_body
                Met.i
                cnt.l
                List lst.s()
              EndStructure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Add value
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure capi_array_string_Add( *this.capi_array_string_body, value.s )
                If *this\cnt > 0
                  LastElement( *this\lst() )
                EndIf
                ; ***
                AddElement( *this\lst() )
                ; ***
                *this\lst() = value
                ; ***
                *this\cnt + 1
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return or set index
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.l capi_array_string_Index( *this.capi_array_string_body, index.l = -1 )
                If index = -1
                  ProcedureReturn ListIndex( *this\lst() )
                ElseIf index >= 0 And index < *this\cnt
                  SelectElement( *this\lst(), index )
                EndIf
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return count of entries
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.l capi_array_string_Count( *this.capi_array_string_body )
                ProcedureReturn *this\cnt
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Delete an entry
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.l capi_array_string_Delete( *this.capi_array_string_body, index.l = 0 )
                If index >= 0 And index < *this\cnt
                  SelectElement( *this\lst(), index )
                  ; ***
                  DeleteElement( *this\lst() )
                  ; ***
                  *this\cnt - 1
                  ; ***
                  If *this\cnt > 0
                    LastElement( *this\lst() )
                  EndIf
                EndIf
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return or modify the value
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.s capi_array_string_Value( *this.capi_array_string_body, index.l, value.s = "{ABCDE-EFC32-32321-0323EC-32DEC-123EF}" )
                If index >= 0 And index < *this\cnt
                  SelectElement( *this\lst(), index )
                  ; ***
                  If value = "{ABCDE-EFC32-32321-0323EC-32DEC-123EF}"
                    ProcedureReturn *this\lst()
                  Else
                    *this\lst() = value
                  EndIf
                Else
                  ProcedureReturn ""
                EndIf
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Clear array
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure capi_array_string_Clear( *this.capi_array_string_body )
                If *this\cnt > 0
                  ClearList( *this\lst() )
                  ; ***
                  *this\cnt = 0
                EndIf
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Sort array
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure capi_array_string_Sort(  *this.capi_array_string_body, nocase.b = #False, increment.b = #True )
              
                If *this\cnt > 0
                  
                  If nocase = #False
                    
                    If increment = #True
                      
                      SortList( *this\lst(), #PB_Sort_Ascending | #PB_Sort_NoCase )
                      
                    Else
                      
                      SortList( *this\lst(), #PB_Sort_Descending | #PB_Sort_NoCase )
                      
                    EndIf
                    
                  Else
              
                    If increment = #True
                      
                      SortList( *this\lst(), #PB_Sort_Ascending )
                      
                    Else
                      
                      SortList( *this\lst(), #PB_Sort_Descending )
                      
                    EndIf
              
                  EndIf
              
                  LastElement( *this\lst() )
              
                EndIf
                
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Find a value. If found, return #true, otherwise #false.
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.b capi_array_string_Find(  *this.capi_array_string_body, value.s, nocase.b = #False )
                
                Define bool.b = #False, v.s
                
                If *this\cnt > 0
                  
                  ForEach *this\lst()
                    
                    v = *this\lst()
                    
                    If v = value And nocase = #False
                      
                      bool = #True
                      
                      Break
                      
                    ElseIf v = value And nocase = #True
                      
                      bool = #True
                      
                      Break
                      
                    ElseIf LCase(v) = LCase(value) And nocase = #True        
                      
                      bool = #True
                      
                      Break
              
                    EndIf
                    
                  Next
                  
                  LastElement( *this\lst() )
                  
                EndIf
                
                ProcedureReturn bool
                
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return the index of a found value, otherwise -1.
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.l capi_array_string_Where(  *this.capi_array_string_body, value.s, nocase.b = #False )
                
                Define pos.l = -1, v.s
                
                If *this\cnt > 0
                  
                  ForEach *this\lst()
                    
                    v = *this\lst()
                    
                    pos + 1
                    
                    If v = value And nocase = #False
                      
                      Break
                      
                    ElseIf v = value And nocase = #True
                      
                      Break
                      
                    ElseIf LCase(v) = LCase(value) And nocase = #True        
                      
                      Break
              
                    EndIf
                    
                  Next
                  
                  LastElement( *this\lst() )
                  
                EndIf
                
                ProcedureReturn pos
                
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return the smallest value
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.s capi_array_string_Min( *this.capi_array_string_body )
                
                Define v.s, t.s, c.l = 32000
                
                If *this\cnt > 0
                  
                  ForEach *this\lst()
                    
                    v = *this\lst()
                    
                    If Len(v) < c : c = Len(v) : t = v : EndIf
                    
                  Next
                  
                  LastElement( *this\lst() )
                  
                EndIf
                
                ProcedureReturn t
                
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Return the largest value
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure.s capi_array_string_Max( *this.capi_array_string_body )
                
                Define v.s, t.s, c.l = 0
                
                If *this\cnt > 0
                  
                  ForEach *this\lst()
                    
                    v = *this\lst()
                    
                    If Len(v) > c : c = Len(v) : t = v : EndIf
                    
                  Next
                  
                  LastElement( *this\lst() )
                  
                EndIf
                
                ProcedureReturn t
                
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Filter values from the list
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure capi_array_string_Filter(  *this.capi_array_string_body, value.s, nocase.b = #False )
              
                Define v.s
              
                If *this\cnt > 0
              
                  ForEach *this\lst()
              
                    v = *this\lst()
              
                    If v = value And nocase = #False
              
                      DeleteElement( *this\lst() ) : *this\cnt - 1
              
                    ElseIf v = value And nocase = #True
              
                      DeleteElement( *this\lst() ) : *this\cnt - 1
              
                    ElseIf LCase(v) = LCase(value) And nocase = #True        
              
                      DeleteElement( *this\lst() ) : *this\cnt - 1
              
                    EndIf
              
                  Next
              
                  If *this\cnt > 0 : LastElement( *this\lst() ) : EndIf
              
                EndIf

              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Class Construtor
              ;
              ; ------------------------------------------------------------------------------------------- ;

              Procedure capi_array_string()
              
                 Protected *this.capi_array_string_body
              
                 *this = AllocateMemory(SizeOf(capi_array_string_body))
                 If *this
                   InitializeStructure(*this, capi_array_string_body)
                    *this\cnt = 0
                    *this\Met.i = ?_capi_array_string_procs_
                 EndIf
              
                 ProcedureReturn *this  
              
              EndProcedure
              
              ; ------------------------------------------------------------------------------------------- ;
              ;
              ;   Class Methods
              ;
              ; ------------------------------------------------------------------------------------------- ;

              DataSection
                _capi_array_string_procs_:
                Data.i @capi_array_string_Add()
                Data.i @capi_array_string_Index()
                Data.i @capi_array_string_Count()
                Data.i @capi_array_string_Delete()
                Data.i @capi_array_string_Value()
                Data.i @capi_array_string_Clear()
                Data.i @capi_array_string_Sort()
                Data.i @capi_array_string_Find()
                Data.i @capi_array_string_Where()
                Data.i @capi_array_string_Min()
                Data.i @capi_array_string_Max()
                Data.i @capi_array_string_Filter()
              EndDataSection

und hier ein test:

Code: Alles auswählen

   test.capi_array_string = capi_array_string()

   test\Add( "Aachen" )
   test\Add( "Köln" )
   test\Add( "Düsseldorf" )
   test\Add( "Münster" )

   For x = 0 to test\Count() - 1
     Debug Test\Value(x)
   Next

   test\Sort( #True, #False )

   Debug ""

   For x = 0 to test\Count() - 1
     Debug Test\Value(x)
   Next

   Debug ""

   Debug test\Min()
   Debug test\Max()

   Debug test\Count()

   test\Clear()

   Debug ""

   Debug "Tada... :-)"

[NicTheQuick]

Min und Max könntest du optimieren, indem du die beiden Werte schon beim Hinzufügen (add()) aktualisierst und beim Abfragen einfach nur zurück gibst.
Desweiteren finde ich deine Definition von Min und Max für Strings merkwürdig. Ich verstehe darunter zumindest nicht die String-Länge.