Weiterreichen von Typen durch mehrere Units

[corpsman]

Servus,

Ich habe verschiedene units, in denen diverse Klassen stehen, nun möchte ich diese in einer Unit sammeln und Verfügbar machen (so dass man nur noch diese eine Unit einbinden muss anstatt alle anderen).
Das geht auch. Was leider nicht geht, ist dass ich das auch mit Aufzählungstypen mache, nur warum geht es nicht. Bzw. Wie macht man es richtig ?

Hier das ganze Beispiel :

Code: Alles auswählen

 
Unit Unit1;
 
{$MODE objfpc}{$H+}
 
Interface
 
Uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
Type
 
  { TForm1 }
 
  TForm1 = Class(TForm)
    Button1: TButton;
    Procedure Button1Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  End;
 
Var
  Form1: TForm1;
 
Implementation
 
Uses unit_a; // Einbinden der Unit_a (würde man Unit_b einbinden dann würde es gehen)
 
{$R *.lfm}
 
{ TForm1 }
 
Procedure TForm1.Button1Click(Sender: TObject);
Var
  d: TDummy;
Begin
  d := TDummy.Create;
  d.P1 := upV1; //Hier kommt der Fehler upv1 not found
 
  d.free;
End;
 
End.
 
 

Code: Alles auswählen

 
 
Unit unit_A;
 
{$MODE objfpc}{$H+}
 
Interface
 
Uses
  Classes, SysUtils, unit_b;
 
Type
  TUserProp = unit_b.TUserProp; // Diesen Typ kennt er leider nicht :(
  TDummy = unit_b.TDummy; // Das hier scheint der Compiler richtig zu machen
 
Implementation
 
End.
 

Code: Alles auswählen

 
Unit unit_b;
 
{$MODE objfpc}{$H+}
 
Interface
 
Uses
  Classes, SysUtils;
 
Type
 
  TUserProp = (upV1, upV2);
 
  TDummy = Class
  private
  public
    P1: TUserProp;
  End;
 
Implementation
 
End.
 

[Scotty]

Warum nicht einfach alle eigenen Typen in eine extra Unit schreiben, und auf diese dann von alle anderen Units zugreifen? Den Zusammenhang mit Klassen verstehe ich hier allerdings nicht.

Code: Alles auswählen

unit utypes;
interface
type
  TEnum=(enOne,enTwo,enThree);
  TEnumSet=set of TEnums;
implementation
end.
 

Code: Alles auswählen

unit utest;
uses 
  utypes;
type
  TMyClass=class
    FEnums:TEnumSet;
  end;
 

[corpsman]

In meinem Beispiel macht dass alles natürlich wenig Sinn.

Ich nutze das ganze auf dem Raspberry Pi, wo ich verschiedene Module einbinde.

Z.B. "C_Berry" -> "ui_wrapper" -> [ "pascalio" | "hwiringpi" ]

nun gibt es in pascalio (nicht von mir sonder von Socke siehe http://www.lazarusforum.de/viewtopic.ph ... lio#p68109) diverse typen wie z.B. TGpioDirection = (gdOut, gdIn);
Mittels eines Compilerswitchs kann man in ui_wrapper zwischen hwiringpi und pascalio umschalten. Wenn Pascalio an ist darf ich TGpioDirection nicht definieren, wenn es aus ist muss ich TGpioDirection definieren.

Ziel ist es, dass ich in "c_berry" nur "ui_wrapper" einbinden muss, weil alle Relevanten Teile von "Ui_wrapper" zur Verfügung gestellt werden. Was die Klassen angeht, so funktioniert dies wunderbar. Bei TGpioDirection eben nicht.

[Scotty]

Ich verstehe dein Problem wohl immer noch nicht. Denn {$ifdef <compilerswitch} {$endif} kennst du sicher.

[corpsman]

Mein Problem ist, dass
ich im Obigen Beispiel von Unit1.pas auf TUserProp nur zugreifen kann, wenn ich unit_a einbinde. Obwohl ich den Typ in unit_a weiterreiche.

Enweder der Compiler "motzt" in Unit_a bei Zeile

Code: Alles auswählen

 
TDummy = unit_b.TDummy; // Das hier scheint der Compiler richtig zu machen
 

dann wäre es OK, das es nicht geht.

Oder eben er "motzt" nicht (was der Fall ist), dann erwarte ich irgendwie aber auch, dass ich aus Unit1 auf TUserProp zugreigen kann. Denn auf TUserProp2 kann ich aus Unit1 zugreifen / ist bekannt. (siehe neue Unit_a.pas)

Code: Alles auswählen

 
Unit unit_A;
 
{$MODE objfpc}{$H+}
 
Interface
 
Uses
  Classes, SysUtils, unit_b;
 
Type
  TUserProp2 = (up1, up2);
  TUserProp = unit_b.TUserProp; // Diesen Typ kennt er leider nicht :(
  TDummy = unit_b.TDummy; // Das hier scheint der Compiler richtig zu machen
 
Implementation
 
End

[theo]

Zugreifen kann man schon, er kennt einfach die Enums nicht.
Das geht aber:

Code: Alles auswählen

  d.P1 := TUserProp(1); //entspricht upV2

Keine Ahnung ob das ein Bug ist.

[corpsman]

So hab das mal als Fehler gemeldet. Mal schaun was draus wird *g*.

[corpsman]

*g* nach einer Diskussion mit einem C-Programmierer habe ich nun eine Möglichkeit gefunden wie der Compiler das ganze schluckt :

Code: Alles auswählen

 
Unit Unit1;
 
{$MODE objfpc}{$H+}
 
Interface
 
Uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
Type
 
  { TForm1 }
 
  TForm1 = Class(TForm)
    Button1: TButton;
    Procedure Button1Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  End;
 
Var
  Form1: TForm1;
 
Implementation
 
Uses unit_a; // Einbinden der Unit_a (würde man Unit_b einbinden dann würde es gehen)
 
{$R *.lfm}
 
{ TForm1 }
 
Procedure TForm1.Button1Click(Sender: TObject);
Var
  d: TDummy;
Begin
  d := TDummy.Create;
  d.P1 := TUserProp.upV1; //So gehts ..
 
  d.free;
End;
 
End.
 

Aber es sieht schon ungewöhnlich aus ...

[theo]

Aber es sieht schon ungewöhnlich aus ...

Ja, tut es.
Und wie begründet man das?
Diese Form der Spezifizierung bei Enums habe ich noch nie gesehen.
Steht das irgendwo so beschrieben?

[corpsman]

Ich lese zwar das FPC Reference Manual, habe sowas bisher aber noch nicht gesehen.

Bin ja auch nicht von allein drauf gekommen, sondern nur durch den "C" Typ. Habs dem Bugreport angefügt, bin mal gespannt, was die dazu sagen..

[martin_frb]

Nicht getestet, aber propier in unit a mal

Code: Alles auswählen

 
const up1 = b.TUserProp.up1;