Ndtyjky

I am trying to convert a set of Bytes to an enumerated set using Generics. But the code does not compile. TValue.FromOrdinal(TypeInfo(T), Ord(B)).AsType does actually correctly return the enumerated value but I cannot include this value in the enumerated set.

interface 



type TByteSet = set of Byte;

type TMyNewEnum = (meZero, meOne, meTwo);

type TMyNewEnumSet = set of TMyNewEnum;



type

  TEnum<T> = class(TObject)

  public

    class function ToString(const aEnumValue: T): string; reintroduce;

    class function FromString(const aEnumString: string; const aDefault: T): T;

    class procedure FromByteSet(const Value: TByteSet; out EnumSet: TMyNewEnumSet);

  end



  implementation

Var

  MyByteSet: TMyByteSet;

  MyEnumSet: TMyNewEnumSet;

...  

class procedure TEnum<T>.FromByteSet(const Value: TByteSet; out EnumSet: TMyNewEnumSet);

var

  B: Byte;

begin

  Assert(PTypeInfo(TypeInfo(T)).Kind = tkEnumeration, 'Type parameter must be an Enumeration');

  for B in Value do

    begin

      EnumSet := EnumSet + TValue.FromOrdinal(TypeInfo(T), Ord(B)).AsType<T>; //This line does not compile

    end;

end;

...







//intended Usage

  MyByteSet := [0, 2];

  TEnum<TMyNewEnum>.FromByteSet(MyByteSet, MyEnumSet); 

  //I would like MyEnumSet to contain [meZero, meTwo]



end.

Any ideas?

You can achieve what you want quite simply, but not the way you are trying to do it (which has been pointed out by others)

If you step through the following program you will see in the debugger that MyEnumSet ends up with the desired value.

program Project3;



{$APPTYPE CONSOLE}



{$R *.res}



uses

  System.SysUtils;





type TByteSet = set of Byte;

type TMyNewEnum = (meZero, meOne, meTwo);

type TMyNewEnumSet = set of TMyNewEnum;



type

  TEnum<T> = class(TObject)

  public

    class procedure FromByteSet(const Value: TByteSet; out EnumSet: T);

  end;



Var

  MyByteSet: TByteSet;

  MyEnumSet: TMyNewEnumSet;





procedure Test( const Parm1 : TByteSet; out Parm2 : TMyNewEnumSet );

var

  iResult : TMyNewEnumSet absolute Parm1;

begin

  Parm2 := iResult;

end;





{ TEnum<T> }



class procedure TEnum<T>.FromByteSet(const Value: TByteSet; out EnumSet : T );

var

  iResult : T absolute Value;

begin

  EnumSet := iResult;

end;



begin

  MyByteSet := [0,2];

  TEnum<TMyNewEnumSet>.FromByteSet( MyByteSet, MyEnumSet);

end.

Of course, you will need to add error checking (bounds and so on) for which you can use RTTI.

What you are attempting is not possible. For it to be possible, you would need to be able to constrain the generic type parameter to be a type over which a set can be formed. But no such generic constraint is supported by the language.

In fact your existing code already contains the tell-tale signs of the root problem. You have:

type

  TEnum<T> = class(TObject)

  public

    class procedure FromByteSet(const Value: TByteSet; out EnumSet: TMyNewEnumSet);

  end;

The elephant in the room here is that FromByteSet makes no reference to T and so is not generic.

In order to make the function generic you would need something like this:

type

  TEnum<T: record> = class(TObject)

  private

    type SetOfT = set of T;

  public

    class procedure FromByteSet(const Value: TByteSet; out EnumSet: SetOfT);

  end;

This does not compile. The compiler objects to the type declaration with:

[dcc32 Error]: E2001 Ordinal type required

That's because the compiler cannot be sure that T is an ordinal type. In order for it to do so, because T is a generic type parameter, you would need there to impose a generic constraint that T was an ordinal type. But the language supports no such constraint.