Exportieren eines TYPES einer "fremden" Unit

[sundance]

Hallo zusammen,

bitte entschuldigt den merkwürdigen Titel; mir wollte einfach kein besserer einfallen...

Es geht um Folgendes:
Für meine Bedürfnisse an "Dateisuche" habe ich mich für die Klasse "TFindFile" von DelphiArea entschieden. Kann einfach alles, was man sich so wünscht.
Für einfache Aufgaben wollte ich nun die Klasse ableiten, sodass z.B. ein Stringliste mit den Ergebnissen gefüllt wird, also:

Delphi-Quellcode:

  TFindFileListBasic = class(FindFile.TFindFile)
  private
    SL: TStringList;
    FStoreFullname: Boolean;
    FTotalFileSize: Int64;
    procedure OnFileMatchEvent(Sender: TObject; const FileInfo: TFileDetails);
  public
    constructor Create(AOwner: TComponent);
    destructor Destroy; override;
    function SearchForFiles: TStringList;
  published
    property StoreFullName: Boolean read FStoreFullname write FStoreFullname;
    property FileSizeOfList: Int64 read FTotalFileSize;
  end;

Der Aufruf sieht dann etwa so aus, um alle Verzeichnisse im Root von C: zu finden:

Delphi-Quellcode:

    var folderList: TStringList;

    with TFindFileListBasic.Create(Self) do begin
      Criteria.Files.Location := 'C:\';
      Criteria.Files.Subfolders := false;       // Nur auf oberster Ebene suchen
      Criteria.Attributes.Directory := fsSet;   // Nur Verzeichnisse suchen
      folderList := SearchForFiles;             // Verzeichnisliste erstellen
      .
      .
      Free;
    end;

Mein Problem ist das Element fsSet, welches als Aufzählungstyp in der Original-Unit FileFind deklariert ist:
  TFileAttributeStatus = (fsIgnore, fsSet, fsUnset, fsAnySet, fsAnyUnset); Nur wegen dieses Typs muss ich (neben meiner Unit mit der abgeleiteten Klasse) auch noch die Original-Unit einbinden. Meine Versuche, das zu umgehen, sind leider gescheitert: Keine der beiden folgenden Zeilen in meiner Unit führen zum Erfolg:

Delphi-Quellcode:

  TFileAttributeStatus = FindFile.TFileAttributeStatus;
  // Fehler: Undeclared Identifier: 'fsSet'

  TFileAttributeStatus = (fsIgnore, fsSet, fsUnset, fsAnySet, fsAnyUnset);
  // Fehler: Incompatible types

Hat jemand eine Idee, wie ich in meiner Unit dieses Type "TFileAttributeStatus" bereitstellen kann, ohne in der Applikation die Unit "FileFind" einzubinden?

P.S. Klar, das ist nur Kosmetik. Mich würde nur interessieren, wie/ob man sowas machen kann, also einen Typ aus einer Unit übernehmen und exportieren...

[BUG]

Du könntest die Aufzählung nochmal selbst definieren und dann entweder (hart) explizit casten (Aufpassen, dass die Werte dieselben sind!) oder dir in Funktion zur "Übersetzung" schreiben (möglicherweise langsamer).

Vielleicht löst ja auch ein Subrange-Typ dein Problem (nicht getestet):
type TFileAttributeStatus = fsIgnore..fsAnyUnset;

[himitsu]

Du solltest auch die Werte deines Enums exportieren ... jeden einzeln

Tipp: Schau mal in meine Variante der TNT-Unicode-Controls ... da hatte ich sowas exzessiv eingesetzt.

[sundance]

@BUG:

Code:

type TFileAttributeStatus = fsIgnore..fsAnyUnset;

funktioniert leider auch nicht...

@himitsu:
Meinst du sowas in der Art?

Code:

{ Meine Unit }
const
  fsIgnore = FindFile.fsIgnore;
  fsSet    = FindFile.fsSet;
  .
  .

Das funktioniert nämlich...

Trotzdem schade, dass man nicht den ganzen TYPE so einfach exportieren kann...

Vielen Dank an alle
.sundance.

[himitsu]

Nja, eigentlich exportiert man ja nicht den Typen, sondern legt ein Alias an.

type
OtherByte = Byte; // Alias (in selbiger oder anderer Unit)
Byte = System.Byte; // gleichnamiger Alias in anderer Unit
TMyByte = type Byte; // neuer Type

Indirekt kann man schon den ganzen Typ exportieren.

Neuerdings kann man (und ist auch, bei vielen RTL/VCL-Enums, auf die fieße Idee gekommen das zu nutzen)...
{$SCOPEDEUNMS ON}

Damit kann man den Enum nur noch mit Scope (Namespace) nutzen und schon braucht man die einzelnen Werte nicht mehr einzeln rüberzuholen.

Delphi-Quellcode:

type
  TFoo = (A, B, Foo);
  {$SCOPEDENUMS ON}
  TBar = (A, B, Bar);
  {$SCOPEDENUMS OFF}

begin
  WriteLn(Integer(Foo));
  WriteLn(Integer(A)); // TFoo.A
  WriteLn(Integer(TBar.B));
  WriteLn(Integer(TBar.Bar));
  WriteLn(Integer(Bar)); // Fehler
end;