#enum

[sphinxdrawsstuff]

D&D SOMNIS - Dark Speech

Through a series of in-jokes (and accent use), we've basically decided that "elvish" in Rayleigh is just fantasy french. Which... not ALL of the party speaks, but just enough to have some shitpost-tier shenanigans.

(I make no excuses for the cursed joke, and take no liability for collateral damage).

[jacob-cs]

An enumeration is a data type consisting of a set of named values, called members. Apple doc says:

original source : https://medium.com/@abhimuralidharan/enums-in-swift-9d792b728835

An enumeration is a data type consisting of a set of named values, called members. Apple doc says:

An enumeration defines a common type for a group of related values and enables you to work with those values in a type-safe way within your code.

Enumerations in Swift are much more flexible, and do not have to provide a value for each case of the enumeration. If a value (known as a “raw” value) isprovided for each enumeration case, the value can be a string, a character, or a value of any integer or floating-point type.

Enumeration Syntax

You introduce enumerations with the enum keyword and place their entire definition within a pair of braces:

enum SomeEnumeration {

// enumeration definition goes here

}

example with type:

enum Gender :String{ case Male case Female }

example without type:

enum Gender { case Male case Female }

The values defined in an enumeration (such as Male and Female) are its enumeration cases. You use the case keyword to introduce new enumeration cases.

Alternatively, you can declare it like :

enum Gender :String { case Male, Female // in a single line like this, separated by commas }

Each enumeration definition defines a brand new type. So, obviously it should have a name starting with capital letter.

We can now set a variable to a enumeration case like so:

var gender: Gender = Gender.male or in short as

var gender = Gender.male

Switch Statement using enums :

switch gender { case .male: print(“Gender is male”) case .female: print(“Gender is female”) // default case is not needed }

Note: In the above example, we don’t use the default case as all the possible enum members are taken care. Only what’s in our enums needs to be checked for. If you do not exhaust all the enum members, then you should add the default case.

HashValue vs RawValue

If you had the enum as we had declared earlier without the type, there is no rawValue available but instead you get a member called hashValue. All enums get a hashValue which is basically like an Index to the order in which the enums were declared. So in the enum called Gender declared above, malewill have a hashValue of 0 and female will have a hashvalue of 1. The reason for this is that hashValues are based on the first item having the index value of 0.

The rawValue on the other hand is a type value that you can assign to the enum members.

enum Gender :String { // enum with type

case male = “I am male”

case female

}

print(Gender.male) // prints “male”

print(Gender.male.rawValue) // prints “I am male”

print(Gender.male.hashValue) // prints 0

accessing values with enums without type:

enum Gender { // enum without type

case male

case female

}

print(Gender.male) // prints “male”

print(Gender.male.rawValue) // Error. rawvalue cannot be accessed for enums without type

print(Gender.male.hashValue) // prints 0

User defined values :

Enum case cannot have a raw value if the enum does not have a raw type.

If enum type is defined, then it cannot have other datatypes as enum member cases.

enum Gender {

case male = 1 //error: enum case cannot have a raw value if the enum does not have a raw type

case female

}

You could use the enum with defined values if enum is having a raw type:

enum Genres:Int{ case One = 1001, Two, Three, Four, Five }

This now enumerates the values and assigns genre.One with 1001 and genres.Two with 1002 and so on.

Note that with this declaration we have also added the var type after the name of the enum. To get the value stored in that enum member, you need to access it’s rawValue property as println("Result -> \(genres.Two.rawValue)") // prints "1002"

When integers are used for raw values, they auto-increment from previous value if no value is specified.

Now, consider the above enum of genres. If one equals 1001, two is given a value of 2000, and if three is not given any value, then the raw value of three will give you 2001.

Enum Genres:Int{ case One = 1001, Two = 2000, Three, Four, Five } print(Genres.Three) // prints "2001"

Enums with methods:

Enums can have methods which can be used on enum cases:

enum WeekDay :String {

case Monday

case Tuesday

func day() ->String { return self.rawValue }

}

print(WeekDay.Monday.day()) // prints Monday

Enum with Associated Values

The following code is copied from Tutorialspoint.com.

enum Student {   case Name(String)   case Mark(Int,Int,Int) } var studDetails = Student.Name("Swift") var studMarks = Student.Mark(98,97,95) switch studMarks {   case .Name(let studName):      println("Student name is: \(studName).")   case .Mark(let Mark1, let Mark2, let Mark3):      println("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")   default:      println("Nothing") }

Enjoy!!

If you enjoyed reading this post, please share and recommend it so others can find it 💚💚💚💚💚💚 !!!!

[sphinxdrawsstuff]

D&D Somniatores + Elisthad - Stickers

Wanted to gift our group(s) something for the holidays, so drew up and printed both party characters for each person + 2 of the DM's fav NPCs, as stickers.

Small exception for one of the players, who is part of just one group, so Rasthun gets a double-feature, as the regular outfit and "party mode" bard-barian. And because another's a player in one and a DM in another did both of their Somniatores guys (cause one died, so he had 2).

Kerren and Dara didn't get printed, since they didn't fit the original sheet, but I finished them up anyway as lil keepsakes~

[sphinxdrawsstuff]

D&D SOMNIS - Mini Urges

Our poor Destruction-wielding paladin-hexblade hasn't had a fight in a while, and it's starting to show.

[sphinxdrawsstuff]

D&D SOMNIS - Halloween 'Fit Swap

A quick lil holiday doodle of the Somniatores group doing some outfit exchanges (and getting creative with Wild Shape in the process).

Oh, and we finally hatched the egg, so feat. our newest member: Dream~ (Who is in fact a Time dragon, not a Black dragon).

[sphinxdrawsstuff]

D&D SOMNIS - The Heist Crew

You don’t often get a DM who will go FULL Ocean’s 11/12/13/8 on you - soundtrack, and scene cuts, and everything (<3) - but when you do, by gods do you need to immortalize this with a spoof poster.

Mainly influenced by the Ocean’s 8 one, but with some mixing here and there~

(feat. humanish!Dara, via some Disguise Self facepaint shenanigans. Also we’ve adopted an unhatched black dragon egg, and its irresponsible to leave a kid alone at that age, so obviously it had to come along).

[dimalink]

Lazarus – ways to extract values ​​from an enumeration

Hello, guys! We're continuing to master Lazarus. It's a wonderful programming language similar to Delphi. There's a data type called an enumeration. And sometimes we want to extract values ​​from it. Here's a funny question: How do we do this? We'll look at that today.

Let's create a standard project in Lazarus. With a Windows window. In the TYPE section, we'll add our enumeration. Let's say it's the seasons of the year: Autumn, Winter, Spring, Summer.

ESeason = (Autumn, Winter, Spring, Summer);

Method 1. WriteStr. The simplest.

And here's the simplest method. It's using WriteStr. We write the desired enumeration type element into a string.

Var MySeason: ESeason; StrVal:String; begin WriteStr(StrVal,MySeason); Memo1.Lines.Add('MySeason=' + StrVal); WriteStr(StrVal,Winter); Memo1.Lines.Add(Winter=' + StrVal); WriteStr(StrVal,ESeason.Spring); Memo1.Lines.Add('ESeason.Spring=' + StrVal); End;

Our StrVal text variable can hold a wide variety of enumeration values. This is all possible! Quite flexible and variable! Notice how many possibilities there are. You can pass a variable of an enumeration type, like MySeason. You can also pass one of the enumeration elements directly by name, like Winter.

And you can pass one of the enumeration values ​​with the full name, as expected. The enumeration type and its specific value separated by a dot. For example, ESeason.Spring.

Method 2. GetEnumName (), Ord(). More complicated.

First, we include TypInfo in Uses. And here's an important detail. TypeInfo doesn't work if enumerations have assigned numeric values.

For example, if an enumeration is defined like this:

ESeason2 = (Autumn=1, Winter, Spring, Summer); //typeinfo doesn't work when there are numeric values!

So, we're continuing to work with our enumeration from the beginning. This will work:

ESeason = (Autumn, Winter, Spring, Summer);

Now let's move on to the code. Extracting a value from the enumeration is done in several steps.

Preliminary detail. We obtain the numeric equivalent of the value via Ord().

Ord(MySeason)

Preliminary detail. We obtain information about our enumeration. Via TypeInfo.

TypeInfo(ESeason)

And we do everything through the conversion operator. Convert to a string using GetEnumType

StrVal:= GetEnumType(TypeInfo(ESeason),Ord(MySeason))

Pass the type of our enumeration to GetEnumType. This is ESeason. And the numeric value we're interested in is MySeason.

IntVal:=ord(MySeason); Example Program var MySeason:ESeason; IntVal: integer; StrVal:String; begin StrVal:=GetEnumName(TypeInfo(ESeason),ord(MySeason)); Memo1.Lines.Add('MySeason Integer value = ' + IntToStr(IntVal)); Memo1.Lines.Add('MySeason String value = ' + StrVal); IntVal:=Ord(Winter); StrVal:=GetEnumName(TypeInfo(ESeason),ord(Winter)); Memo1.Lines.Add('Winter Integer - ' + IntToStr(IntVal)); Memo1.Lines.Add('Winter String - ' + StrVal); IntVal:=Ord(ESeason.Spring); StrVal:=GetEnumName(TypeInfo(ESeason),ord(ESeason.Spring)); Memo1.Lines.Add('ESeason.Spring Integer - ' + IntToStr(IntVal)); Memo1.Lines.Add('ESeason.Spring String - ' + StrVal); End;

Method 3. Manually assigning values. The most sophisticated method.

To do this, we'll create a chain. We'll also write the identifiers into a string array.

This still works as a constant. And with ESeason.

const MySeasonNames: Array[ESeason] of string =('Autumn','Winter','Spring','Summer');

Let me remind you that the enumeration itself looks like this:

ESeason = (Autumn, Winter, Spring, Summer);

We're essentially associating the enumeration with a special array. In the array, all values ​​are written as strings.

Now we can access this array by passing the enumeration value as an array index.

For example, like this

StrVal:=MySeasonNames[MySeason];

Or like this

StrVal:=MySeasonNames[Winter];

Or like this

StrVal:=MySeasonNames[ESeason.Spring];

We've sort of mapped the array, associating it with the enumeration elements. A clever move. And now we access our map. By throwing enumeration values ​​into an array. The array index is the enumeration value.

Var MySeason:ESeason; IntVal: integer; StrVal: String; begin StrVal:=MySeasonNames[MySeason]; Memo1.Lines.Add('MySeason =' + StrVal); StrVal:=MySeasonNames[Winter]; Memo1.Lines.Add('Winter - ' + StrVal); StrVal:=MySeasonNames[ESeason.Spring]; Memo1.Lines.Add('MySeason.Spring - ' + StrVal); End;

Those are three such methods! Delphi is interesting! Let's learn, guys! I'm learning too! And I'm learning everything gradually. Sometimes I spend a lot of time even on a couple of lines of code.

Dima Link is making retro videogames, apps, a little of music, write stories, and some retro more.

WEBSITE: http://www.dimalink.tv-games.ru/home_eng.html ITCHIO: https://dimalink.itch.io/

TUMBLR: https://dimalink.tumblr.com/ BLOGGER: https://dimalinkeng.blogspot.com/ MASTODON: https://mastodon.social/@DimaLink

[pythonjobsupport]

VBA - 29: Const & Enum Full Guide Powerful Concepts for Real-Life Project | VBA Series | Learn excel

Namaste Dosto! Aaj ke is video mein hum VBA ke powerful concepts — Const aur Enum — ko simple language aur real-life … source