delete

[edel]

Ja, war ja nur ein beispiel.

Maps,Listen und Array pointer solltest du aber Ignorieren. Die hatte ich gerade etwas verdraengt

[gekkonier]

Hi!

Super Projekt, Hut ab!
Die Installation ist auch sehr einfach, die "Syntax" auch einfach und verständlich - Extrabonus wegen Open Source gibts auch noch!

Ich habe ein Problem:
Ich habe das Projekt mit dem Installer installiert (auf einer frischen Purebasic 4.31 Installation - alles hat funktioniert und ich probiere gerade die mitgelieferten Demos aus.
Jedesmal wenn ich ein Demo habe wo FreeObject verwendet wird starte (oder mit unten anstehendem Code kann mans auch ausprobieren) bekomme ich eine Fehlermeldung:

Zeile x: ClearStructure() ist keine Funktion, Array, Makro oder LinkedList.

Zeile x ist immer die, wo FreeObject() verwendet wird.

Hier der Testcode:

Code: Alles auswählen

Class Test
  Public Method Testit()
    Debug "test"
  EndMethod
EndClass

*Hallo.Test = NewObject()
*Hallo\Testit()

; bis hierher funktionierts!

; wenn ich die folgende Zeile hinzufüge kommt der Fehler:

*Hallo.Test = FreeObject()

[edel]

ClearStructure gibt es erst seit 4.4

[gekkonier]

Oh, das erklärt den Fehler!
Muss ich mir wohl doch die Beta installieren wenn ich das testen will.
Danke!

[edel]

so z.b.

Code: Alles auswählen

Procedure Test(List *myList.point())
  
  *p.point = AddElement(*myList())
  *p\x = 10
  *p\y = 12
  
EndProcedure 


NewList MyList.point()

Test(@MyList())

ForEach MyList()
  Debug MyList()\x
  Debug MyList()\y
Next 

[edel]

Vielen Dank.

Hab da gleich noch eine Feature-Request

Viele wuenschen sich ja Listen oder auch Maps in Strukturen (Klassen), und da soop ja eh den Text parst,
koennte man das da nicht mit einbauen?

Im Prinzip stelle ich mir das so vor, dass die Listen oder Maps einfach Global erstellt werden, der Name
besteht aus der Klasse und der Instanz.

Code: Alles auswählen

Class Test  
  Public NewMap myMap.point()        
  
  ;[...]
  
EndClass 

*t.Test = NewObject

*t\myMap("1")\x = 10
*t\myMap("1")\y = 10

*t\myMap("2")\x = 11
*t\myMap("2")\y = 11

Umsetzen koennte man das vielleicht mit Macros

Code: Alles auswählen

Macro NewInstancMap(Class,Instance,typ)
  NewMap Class#Instance#.typ()   
EndMacro 

Macro GetNameMap(Class,Instance,typ)
  Class#Instance#.typ
EndMacro 

NewInstancMap(test,12,point)

GetNameMap(test,12,point)("pos1")\x = 10
GetNameMap(test,12,point)("pos1")\y = 11

GetNameMap(test,12,point)("pos2")\x = 13
GetNameMap(test,12,point)("pos2")\y = 14

ForEach GetNameMap(test,12,point)()
  Debug GetNameMap(test,12,point)()\x
  Debug GetNameMap(test,12,point)()\y
  Debug "---------"
Next 

Was haeltst du davon?

[edel]

Naja, Listen usw hab ich auch, nur waere es halt genial wenn das nativ unterstuetzt werden koennte.

edit...
Mist, das mit dem macros funktioniert ja leider nicht zur laufzeit ...

[edel]

Hab mir jetzt mal ein paar mehr Gedanken dazu gemacht bzw ein wenig getestet.

Folgendes waere optimal

Code: Alles auswählen

Class Test
  Public NewMap myMap.struc0()
  
  Public Method Save(var.i)
    This\myMap("pos",var)
  EndMethod
  
EndClass 

*t.test = NewObject
*t\Save(12)
Debug *t\myMap("pos")

*a.test = NewObject
*a\myMap("pos") = 10

Umsetzen kann man das, in dem man eine Globale Map erstellt (Threaded statt Global waere sinnvoller, weiss aber noch nicht wie das geht), und vor jeder Nutzung der eigenen Map (also der in der Klasse) setzt man den Zeiger der globalen Map auf die eigene.

Beispiel:

Code: Alles auswählen

! Macro copyMap_g Map,TempMap{ ; global
!   MOV eax,[v_#Map]      ; eax fuer x86, rax fuer 64 bit
!   MOV [m_#TempMap],eax  ; eax fuer x86, rax fuer 64 bit
!}

! Macro copyMap_p Map,TempMap{ ; proc
!   MOV eax,[p.v_#Map]    ; eax fuer x86, rax fuer 64 bit
!   MOV [m_#TempMap],eax  ; eax fuer x86, rax fuer 64 bit
!}

Macro ChangeMapProc(_a,_b)
!copyMap_p _a,_b
EndMacro

Macro ChangeMapGlobal(_a,_b)
!copyMap_g _a,_b
EndMacro 

;-------------test

Procedure CreateMyClassMap()  
  Global NewMap temp_map()  ;hier muss man noch die Struktur anpassen, je nachdem welcher Typ die Map haben soll
  !mov eax,[m_temp_map]   ; eax fuer x86, rax fuer 64 bit
  ProcedureReturn 
EndProcedure

Global NewMap myClassMap() ;hier muss man noch die Struktur anpassen, je nachdem welcher Typ die Map haben soll

Procedure Methode(Map) : ChangeMapProc(Map,myClassMap)
  myClassMap("1") = Random(10)
  myClassMap("2") = Random(10)
  myClassMap("3") = Random(10)  
EndProcedure

Procedure Methode2(Map) : ChangeMapProc(Map,myClassMap)
  ForEach myClassMap()
    Debug myClassMap()
  Next 
EndProcedure

myMapVar1 = CreateMyClassMap() : ChangeMapGlobal(myMapVar1,myClassMap)
Methode(myMapVar1)

myMapVar2 = CreateMyClassMap() : ChangeMapGlobal(myMapVar2,myClassMap)
Methode(myMapVar2)

Methode2(myMapVar1)
Debug "------"
Methode2(myMapVar2)
Debug "------"
Methode2(myMapVar1)

Ich wuerde es auch gerne selber einbauen, komme nur nicht mit deinem Code klar. Darfst mir
aber gerne erklaeren wo ich da was einbauen kann

[gekkonier]

Hi!
nochmal (falls ich es schon schrieb) danke für die Lib - das macht echt fun damit zu basteln.
Ich hätte eine Frage - ist es irgendwie möglich quasi Mixin's zu machen?
In der Rubywelt funktioniert das so, dass man quasi ein "Modul" baut, das man dann in die Klasse einmixen kann.
Dabei kann man sowohl mehrere Module in eine Klasse mixen, als auch das Modul in mehreren Klassen verwenden. Das kann man quasi wie eine Art Bausatz für Klassen sehen. Anbei ein kleines Rubybeispiel:

Code: Alles auswählen

module Component1
    def comp1hallo
        puts "hallo1"
    end
end

module Component2
    def comp2hallo
        puts "hallo2"
    end
end

module Component3
    def comp2hallo
        puts "hallo3"
    end
end

class Class1
    include Component1
    include Component2
end

class Class2
    include Component1
    include Component3
end

c1 = Class1.new
c2 = Class2.new

c1.comp1hallo
c1.comp2hallo
c2.comp1hallo
c2.comp2hallo

Ausgabe:

Code: Alles auswählen

hallo1
hallo2
hallo1
hallo3

Damit wäre es z.B möglich Verhaltenspattern für verschiedene Entities in einem Spiel vorzuimplementieren und würde eine Vererbungsorgie unter Umständen bei grösseren Projekten minimieren. Wenn ein Modul eine Methode implementiert, die bereits zuvor entweder eingemixt, geerbt oder implementiert wurde sollte die zuletzt eingemixte Methode (Procedure) verwendet werden.

[edel]

Hi Sirhc, vielleicht ist es etwas untergegangen, aber koenntest du noch schreiben
wo ich was einbauen muss damit der Code von oben umgesetzt werden kann?