কীভাবে সুইফটে এনএস_অপশনস-স্টাইল বিটমাস্কের তালিকা তৈরি করবেন?


137

সি এপিআইগুলির সাথে কথোপকথন সম্পর্কে অ্যাপলের ডকুমেন্টেশনে, তারা বর্ণনা করেছেন যেভাবে NS_ENUMচিহ্নিত সি-স্টাইলের গণনাগুলি সুইফ্ট এনুমারেশন হিসাবে আমদানি করা হয়। এটি বোধগম্য হয় এবং যেহেতু সুইফ্টের গণনাগুলি সহজেই enumমান ধরণের হিসাবে সরবরাহ করা হয় তা কীভাবে আমাদের নিজের তৈরি করতে হয় তা সহজেই দেখা যায় ।

আরও নীচে, এটি NS_OPTIONSসি-স্টাইল বিকল্পগুলি সম্পর্কে এটি বলেছে :

সুইফট NS_OPTIONSম্যাক্রোর সাথে চিহ্নিত বিকল্পগুলিও আমদানি করে । যেখানে অপশন আমদানিকৃত enumerations ক্ষেত্রে একই রকম ব্যবহার, বিকল্প যেমন কিছু, bitwise অপারেশন, সমর্থন করতে পারে না &, |এবং ~। অবজেক্টিভ-সিতে, আপনি ধ্রুবক শূন্য ( 0) সহ একটি খালি বিকল্প সেট উপস্থাপন করেন । সুইফটে, nilকোনও বিকল্পের অনুপস্থিতি উপস্থাপন করতে ব্যবহার করুন।

সুইফটে কোনও optionsমান ধরণের নেই বলে প্রদত্ত , আমরা কীভাবে কাজ করতে সি-স্টাইল বিকল্পগুলি পরিবর্তন করতে পারি?


3
@ ম্যাট-এর অত্যন্ত বিখ্যাত "এনএসএইচসিস্টার" এর একটি বিস্তৃত বর্ণনা রয়েছে RawOptionsSetType: nshipster.com/rawoptionsettype
ক্লাস

উত্তর:


258

সুইফট 3.0

সুইফট ২.০-এর প্রায় সমান। অপশনসেটটাইপটির নাম পরিবর্তন করে অপশনসেট করা হয় এবং এনামগুলি কনভেনশন অনুসারে লোয়ার কেস লিখিত হয়।

struct MyOptions : OptionSet {
    let rawValue: Int

    static let firstOption  = MyOptions(rawValue: 1 << 0)
    static let secondOption = MyOptions(rawValue: 1 << 1)
    static let thirdOption  = MyOptions(rawValue: 1 << 2)
}

noneবিকল্প সরবরাহ করার পরিবর্তে , সুইফট 3 সুপারিশটি কেবল খালি অ্যারে আক্ষরিক ব্যবহার করা:

let noOptions: MyOptions = []

অন্যান্য ব্যবহার:

let singleOption = MyOptions.firstOption
let multipleOptions: MyOptions = [.firstOption, .secondOption]
if multipleOptions.contains(.secondOption) {
    print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.thirdOption) {
    print("allOptions has ThirdOption")
}

সুইফট ২.০

সুইফট ২.০-তে, প্রোটোকল এক্সটেনশানগুলি এগুলির জন্য বেশিরভাগ বয়লারপ্লেটের যত্ন নেয়, যা এখন কাঠামোর মতো আমদানি করা হয় OptionSetType। ( RawOptionSetTypeসুইফট 2 বিটা 2 হিসাবে অদৃশ্য হয়ে গেছে) ঘোষণাটি এত সহজ far

struct MyOptions : OptionSetType {
    let rawValue: Int

    static let None         = MyOptions(rawValue: 0)
    static let FirstOption  = MyOptions(rawValue: 1 << 0)
    static let SecondOption = MyOptions(rawValue: 1 << 1)
    static let ThirdOption  = MyOptions(rawValue: 1 << 2)
}

এখন আমরা এর সাথে সেট-ভিত্তিক শব্দার্থ ব্যবহার করতে পারি MyOptions:

let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = [.FirstOption, .SecondOption]
if multipleOptions.contains(.SecondOption) {
    print("multipleOptions has SecondOption")
}
let allOptions = MyOptions(rawValue: 7)
if allOptions.contains(.ThirdOption) {
    print("allOptions has ThirdOption")
}

সুইফট ১.২

উদ্দেশ্য সি বিকল্প (SWIFT দ্বারা আমদানি করা হয় এ খুঁজছি UIViewAutoresizingউদাহরণস্বরূপ,), আমরা দেখতে পারেন অপশন হিসেবে ঘোষিত হয় structযে প্রোটোকল কে কনর্ফাম করে RawOptionSetType, যেটা ঘুরে কনর্ফাম করা _RawOptionSetType, Equatable, RawRepresentable, BitwiseOperationsType, এবং NilLiteralConvertible। আমরা আমাদের নিজস্ব তৈরি করতে পারি:

struct MyOptions : RawOptionSetType {
    typealias RawValue = UInt
    private var value: UInt = 0
    init(_ value: UInt) { self.value = value }
    init(rawValue value: UInt) { self.value = value }
    init(nilLiteral: ()) { self.value = 0 }
    static var allZeros: MyOptions { return self(0) }
    static func fromMask(raw: UInt) -> MyOptions { return self(raw) }
    var rawValue: UInt { return self.value }

    static var None: MyOptions { return self(0) }
    static var FirstOption: MyOptions   { return self(1 << 0) }
    static var SecondOption: MyOptions  { return self(1 << 1) }
    static var ThirdOption: MyOptions   { return self(1 << 2) }
}

এখন আমরা এই নতুন বিকল্প সেটটিকে চিকিত্সা করতে পারি MyOptions, যেমন অ্যাপলের ডকুমেন্টেশনে বর্ণিত: আপনি পছন্দ enumমতো সিনট্যাক্স ব্যবহার করতে পারেন :

let opt1 = MyOptions.FirstOption
let opt2: MyOptions = .SecondOption
let opt3 = MyOptions(4)

এবং এটি এমন আচরণ করে যেমন আমরা বিকল্পগুলির আচরণের প্রত্যাশা করতাম:

let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption != nil {     // see note
    println("multipleOptions has SecondOption")
}
let allOptions = MyOptions.fromMask(7)   // aka .fromMask(0b111)
if allOptions & .ThirdOption != nil {
    println("allOptions has ThirdOption")
}

আমি সমস্ত সন্ধান / প্রতিস্থাপন ছাড়াই একটি সুইফ্ট বিকল্প সেট তৈরি করতে একটি জেনারেটর তৈরি করেছি ।

সর্বশেষ: সুইফট 1.1 বিটা 3 এর জন্য পরিবর্তনসমূহ।


1
এটা আমার জন্য কাজ করে নি, যদি না আমি তৈরি valueএকটি UInt32। আপনাকে কোনও ফাংশনও সংজ্ঞায়িত করতে হবে না, প্রাসঙ্গিক ফাংশনগুলি ইতিমধ্যে RawOptionSetএর (যেমন func |<T : RawOptionSet>(a: T, b: T) -> T) জন্য সংজ্ঞায়িত করা হয়েছে
ডেভিড লসন

ধন্যবাদ, ফাংশন সম্পর্কে দুর্দান্ত বিষয় - আমার মনে হয় সংকলকটি যখন আমার কাছে প্রোটোকলের বাকী বাক্য স্থানটি ছিল না তখন তাদের সম্পর্কে অভিযোগ করছিল। কোন সমস্যা নিয়ে আপনি দেখেছেন UInt? এটা আমার জন্য ভাল কাজ করছে।
নেট কুক

2
কাঠামোর পরিবর্তে এনাম ব্যবহার করার মতো কোনও সমাধান রয়েছে? আমার উদ্দেশ্য-সি এর সাথে সামঞ্জস্য করা আমার দরকার ...
জুই

1
@ জোভিenum CollisionTypes: UInt32 { case Player = 1 case Wall = 2 case Star = 4 case Vortex = 8 case Finish = 16 }
এমসিসিফয়এলবিআই

1
এই উদাহরণস্বরূপ, অ্যাপলের ডক্স সত্যিই ভাল।
মিঃ রজারস

12

এক্সকোড 6.1 বিটা 2 RawOptionSetTypeপ্রোটোকলে কিছু পরিবর্তন এনেছে (দেখুন এই এয়ারস্পিডবেসিটি ব্লগ এন্ট্রি এবং অ্যাপল প্রকাশের নোটগুলি দেখুন )।

নেট কুকের উদাহরণের ভিত্তিতে এখানে একটি আপডেট সমাধান রয়েছে। আপনি নিজের বিকল্প সেটটিকে এভাবে নির্ধারণ করতে পারেন:

struct MyOptions : RawOptionSetType, BooleanType {
    private var value: UInt
    init(_ rawValue: UInt) { self.value = rawValue }

    // MARK: _RawOptionSetType
    init(rawValue: UInt) { self.value = rawValue }

    // MARK: NilLiteralConvertible
    init(nilLiteral: ()) { self.value = 0}

    // MARK: RawRepresentable
    var rawValue: UInt { return self.value }

    // MARK: BooleanType
    var boolValue: Bool { return self.value != 0 }

    // MARK: BitwiseOperationsType
    static var allZeros: MyOptions { return self(0) }

    // MARK: User defined bit values
    static var None: MyOptions          { return self(0) }
    static var FirstOption: MyOptions   { return self(1 << 0) }
    static var SecondOption: MyOptions  { return self(1 << 1) }
    static var ThirdOption: MyOptions   { return self(1 << 2) }
    static var All: MyOptions           { return self(0b111) }
}

এর পরে ভেরিয়েবল সংজ্ঞায়িত করতে এটি এর মতো ব্যবহার করা যেতে পারে:

let opt1 = MyOptions.FirstOption
let opt2:MyOptions = .SecondOption
let opt3 = MyOptions(4)

এবং বিটের জন্য পরীক্ষার জন্য এটি পছন্দ করুন:

let singleOption = MyOptions.FirstOption
let multipleOptions: MyOptions = singleOption | .SecondOption
if multipleOptions & .SecondOption {
    println("multipleOptions has SecondOption")
}

let allOptions = MyOptions.All
if allOptions & .ThirdOption {
    println("allOptions has ThirdOption")
}

8

ডকুমেন্টেশন থেকে সুইফট 2.0 উদাহরণ:

struct PackagingOptions : OptionSetType {
    let rawValue: Int
    init(rawValue: Int) { self.rawValue = rawValue }

    static let Box = PackagingOptions(rawValue: 1)
    static let Carton = PackagingOptions(rawValue: 2)
    static let Bag = PackagingOptions(rawValue: 4)
    static let Satchel = PackagingOptions(rawValue: 8)
    static let BoxOrBag: PackagingOptions = [Box, Bag]
    static let BoxOrCartonOrBag: PackagingOptions = [Box, Carton, Bag]
}

আপনি এটি এখানে খুঁজে পেতে পারেন


6

সুইফট 2 এ (বর্তমানে এক্সকোড 7 বিটার অংশ হিসাবে বিটা), NS_OPTIONSস্টাইলের ধরণগুলি নতুন OptionSetTypeধরণের সাব টাইপ হিসাবে আমদানি করা হয় । এবং নতুন প্রোটোকল এক্সটেনশান বৈশিষ্ট্যটির জন্য ধন্যবাদ এবং OptionSetTypeস্ট্যান্ডার্ড লাইব্রেরিতে যেভাবে প্রয়োগ করা হয়েছে, আপনি নিজের নিজস্ব প্রকারগুলি ঘোষণা করতে পারেন OptionsSetTypeযা আমদানি করা- NS_OPTIONSস্টাইলের ধরণের সমস্ত আমদানি-পদ্ধতিগুলি বাড়ায় এবং পেতে পারে।

কিন্তু এই ফাংশনগুলি বিটওয়াইজ গাণিতিক অপারেটরগুলির উপর ভিত্তি করে তৈরি হয় না। সি-তে অ-একচেটিয়া বুলিয়ান বিকল্পগুলির একটি সেট নিয়ে কাজ করার জন্য একটি ক্ষেত্রের মধ্যে বিস্কুট বিটগুলি মাস্কিং এবং বার্ডলিং প্রয়োজন an সত্যই, বিকল্পগুলির একটি সেট হ'ল এক অনন্য আইটেমের সংকলন। তাই প্রোটোকল OptionsSetTypeথেকে সমস্ত পদ্ধতি পায় SetAlgebraTypeযেমন অ্যারে আক্ষরিক বাক্য গঠন থেকে তৈরি করা, কোয়েরি contains, মাস্কিং intersectionইত্যাদি ইত্যাদি (কোন সদস্যতার পরীক্ষার জন্য কোন মজার চরিত্রটি ব্যবহার করা উচিত তা আর মনে করার দরকার নেই!)


5
//Swift 2.0
 //create
    struct Direction : OptionSetType {
        let rawValue: Int
        static let None   = Direction(rawValue: 0)
        static let Top    = Direction(rawValue: 1 << 0)
        static let Bottom = Direction(rawValue: 1 << 1)
        static let Left   = Direction(rawValue: 1 << 2)
        static let Right  = Direction(rawValue: 1 << 3)
    }
//declare
var direction: Direction = Direction.None
//using
direction.insert(Direction.Right)
//check
if direction.contains(.Right) {
    //`enter code here`
}

4

আপনার যদি ওজেক্টিভ-সি এর সাথে ইন্টারঅ্যাপের দরকার নেই এবং কেবল সুইফটে বিট মাস্কের পৃষ্ঠতল শব্দার্থবিদ্যা চান , আমি বিটওয়াইসপশনস নামে একটি সাধারণ "গ্রন্থাগার" লিখেছি যা এটি নিয়মিত সুইফ্ট গণনার সাহায্যে করতে পারে, যেমন:

enum Animal: BitwiseOptionsType {
    case Chicken
    case Cow
    case Goat
    static let allOptions = [.Chicken, .Cow, .Goat]
}

var animals = Animal.Chicken | Animal.Goat
animals ^= .Goat
if animals & .Chicken == .Chicken {
    println("Chick-Fil-A!")
}

ইত্যাদি। এখানে কোন আসল বিট উল্টানো হচ্ছে না। এগুলি অস্বচ্ছ মানগুলির উপর অপারেশন সেট করে। আপনি এখানে সংক্ষেপে খুঁজে পেতে পারেন ।


@ ক্রিসপ্রিন্স সম্ভবত এটি কারণ এটি সুইফট ১.০ এর জন্য তৈরি করা হয়েছিল এবং তখন থেকে আপডেট হয়নি।
গ্রেগরি হিগলি

আমি আসলে এটির একটি সুইফট ২.০ সংস্করণে কাজ করছি।
গ্রেগরি হিগলি

2

রিকস্টার ইতিমধ্যে উল্লিখিত হিসাবে, আপনি সুইফট ২.০ এ অপশনসেটটাইপ ব্যবহার করতে পারেন । OptionSetTypeপ্রোটোকলের সাথে সঙ্গতিপূর্ণ হিসাবে এনএস_অপশনগুলি আমদানি হয়ে যায় , যা বিকল্পগুলির জন্য একটি সেট-মত ইন্টারফেস উপস্থাপন করে:

struct CoffeeManipulators : OptionSetType {
    let rawValue: Int
    static let Milk     = CoffeeManipulators(rawValue: 1)
    static let Sugar    = CoffeeManipulators(rawValue: 2)
    static let MilkAndSugar = [Milk, Sugar]
}

এটি আপনাকে এই কাজের উপায় দেয়:

struct Coffee {
    let manipulators:[CoffeeManipulators]

    // You can now simply check if an option is used with contains
    func hasMilk() -> Bool {
        return manipulators.contains(.Milk)
    }

    func hasManipulators() -> Bool {
        return manipulators.count != 0
    }
}

2

যদি আমাদের কেবলমাত্র কার্যকারিতাটির প্রয়োজন হয় তবে বিকল্পগুলির সাথে একত্রিত করার |এবং &নেট কুকের উত্তরের বিকল্পের সাথে একটি বিশেষ বিকল্প রয়েছে কিনা তা যাচাই করার একটি উপায় হল :

একটি বিকল্প তৈরি করুন protocolএবং ওভারলোড |এবং &:

protocol OptionsProtocol {

    var value: UInt { get }
    init (_ value: UInt)

}

func | <T: OptionsProtocol>(left: T, right: T) -> T {
    return T(left.value | right.value)
}

func & <T: OptionsProtocol>(left: T, right: T) -> Bool {
    if right.value == 0 {
        return left.value == 0
    }
    else {
        return left.value & right.value == right.value
    }
}

এখন আমরা আরও সহজভাবে বিকল্প বিকল্পগুলি তৈরি করতে পারি:

struct MyOptions: OptionsProtocol {

    private(set) var value: UInt
    init (_ val: UInt) {value = val}

    static var None: MyOptions { return self(0) }
    static var One: MyOptions { return self(1 << 0) }
    static var Two: MyOptions { return self(1 << 1) }
    static var Three: MyOptions { return self(1 << 2) }
}

সেগুলি নিম্নলিখিত হিসাবে ব্যবহার করা যেতে পারে:

func myMethod(#options: MyOptions) {
    if options & .One {
        // Do something
    }
}

myMethod(options: .One | .Three) 

2

অন্য যে কেউ ভাবছেন যে আপনি যৌগিক বিকল্পগুলি একত্রিত করতে পারেন তা কেবল অতিরিক্ত উদাহরণ পোস্ট করা ing আপনি পারেন, এবং এগুলি একত্রিত করে আপনি আশা করেন যে আপনি যদি ভাল পুরানো বিটফিল্ড ব্যবহার করেন:

struct State: OptionSetType {
    let rawValue: Int
    static let A      = State(rawValue: 1 << 0)
    static let B      = State(rawValue: 1 << 1)
    static let X      = State(rawValue: 1 << 2)

    static let AB:State  = [.A, .B]
    static let ABX:State = [.AB, .X]    // Combine compound state with .X
}

let state: State = .ABX
state.contains(.A)        // true
state.contains(.AB)       // true

এটা তোলে সেট চ্যাপ্টা [.AB, .X]মধ্যে [.A, .B, .X](কমপক্ষে শব্দার্থগতভাবে):

print(state)      // 0b111 as expected: "State(rawValue: 7)"
print(State.AB)   // 0b11 as expected: "State(rawValue: 3)"

1

অন্য কারও এটি উল্লেখ করা হয়নি - এবং আমি কিছুটা ঝুঁকির পরে এটির উপরে এক ধরণের blundered করেছি - তবে একটি সুইফ্ট সেটটি বেশ ভালভাবে কাজ করছে বলে মনে হচ্ছে।

কিছুটা মুখোশ আসলে কী উপস্থাপন করছে তা সম্পর্কে যদি আমরা (সম্ভবত কোনও ভেন চিত্রের কাছে?) ভাবি, তবে এটি সম্ভবত একটি খালি সেট।

অবশ্যই, প্রথম নীতিগুলি থেকে সমস্যার দিকে এগিয়ে যাওয়ার ক্ষেত্রে আমরা বিটওয়াইজ অপারেটরদের সুবিধাদি হারাতে পারি, তবে শক্তিশালী সেট-ভিত্তিক পদ্ধতিগুলি লাভ করি যা পাঠযোগ্যতার উন্নতি করে।

উদাহরণস্বরূপ আমার টিঙ্কিং এখানে রয়েছে:

enum Toppings : String {
    // Just strings 'cause there's no other way to get the raw name that I know of...
    // Could be 1 << x too...
    case Tomato = "tomato"
    case Salami = "salami"
    case Cheese = "cheese"
    case Chicken = "chicken"
    case Beef = "beef"
    case Anchovies = "anchovies"

    static let AllOptions: Set<Toppings> = [.Tomato, .Salami, .Cheese, .Chicken, .Anchovies, .Beef]
}

func checkPizza(toppings: Set<Toppings>) {
    if toppings.contains(.Cheese) {
        print("Possible dairy allergies?")
    }

    let meats: Set<Toppings> = [.Beef, .Chicken, .Salami]
    if toppings.isDisjointWith(meats) {
        print("Vego-safe!")
    }
    if toppings.intersect(meats).count > 1 {
        print("Limit one meat, or 50¢ extra charge!")
    }

    if toppings == [Toppings.Cheese] {
        print("A bit boring?")
    }
}

checkPizza([.Tomato, .Cheese, .Chicken, .Beef])

checkPizza([.Cheese])

আমি এটিকে সুন্দর মনে করি কারণ আমি মনে করি এটি সি-স্টাইলের সমাধানগুলি মানিয়ে নেওয়ার চেষ্টা না করেই সমস্যার প্রথম নীতি পদ্ধতির থেকে এসেছে - অনেকটা সুইফ্টের মতো -।

এছাড়াও ওবিজে-সি ব্যবহারের কিছু ঘটনা শুনতে শুনতে চাই যা এই ভিন্ন দৃষ্টান্তটিকে চ্যালেঞ্জ জানায়, যেখানে পূর্ণসংখ্যার কাঁচা মানগুলি এখনও মেধা দেখায়।


1

অর্ডার হার্ড বিট অবস্থানের কোডিং এড়াতে, এড়ানো সম্ভব নয় যখন ব্যবহারে (1 << 0), (1 << 1), (1 << 15)ইত্যাদি বা এমনকি খারাপ 1, 2, 16384ইত্যাদি বা কিছু হেক্সাডেসিমেল প্রকরণ, এক প্রথমে একটি বিট সংজ্ঞায়িত পারে enum, তাহলে বললেন উঠুক enum বিট পূরণবাচক হিসাব করুন:

// Bits
enum Options : UInt {
    case firstOption
    case secondOption
    case thirdOption
}

// Byte
struct MyOptions : OptionSet {
    let rawValue: UInt

    static let firstOption  = MyOptions(rawValue: 1 << Options.firstOption.rawValue)
    static let secondOption = MyOptions(rawValue: 1 << Options.secondOption.rawValue)
    static let thirdOption  = MyOptions(rawValue: 1 << Options.thirdOption.rawValue)
}

সবেমাত্র যুক্ত উদাহরণ যেখানে আপনাকে কোনও হার্ড কোড করতে হবে না।
পিটার আহলবার্গ

1

আমি যে দুটি মান পেতে পারি তা ব্যবহার করি, অ্যারেগুলি সূচিকরণের জন্য কাঁচাভালু এবং পতাকাগুলির জন্য মূল্য।

enum MyEnum: Int {
    case one
    case two
    case four
    case eight

    var value: UInt8 {
        return UInt8(1 << self.rawValue)
    }
}

let flags: UInt8 = MyEnum.one.value ^ MyEnum.eight.value

(flags & MyEnum.eight.value) > 0 // true
(flags & MyEnum.four.value) > 0  // false
(flags & MyEnum.two.value) > 0   // false
(flags & MyEnum.one.value) > 0   // true

MyEnum.eight.rawValue // 3
MyEnum.four.rawValue  // 2

এবং যদি কারও বেশি প্রয়োজন হয় তবে একটি গণিত সম্পত্তি যুক্ত করুন।

enum MyEnum: Int {
    case one
    case two
    case four
    case eight

    var value: UInt8 {
        return UInt8(1 << self.rawValue)
    }

    var string: String {
        switch self {
        case .one:
            return "one"
        case .two:
            return "two"
        case .four:
            return "four"
        case .eight:
            return "eight"
        }
    }
}

1

পুনঃ স্যান্ডবক্স এবং বুকমার্ক তৈরি বিভিন্ন বিকল্পের সাহায্যে বিকল্প সেট ব্যবহার করে

let options:NSURL.BookmarkCreationOptions = [.withSecurityScope,.securityScopeAllowOnlyReadAccess]
let temp = try link.bookmarkData(options: options, includingResourceValuesForKeys: nil, relativeTo: nil)

সৃষ্টির জন্য বিকল্পগুলি একত্রিত করার প্রয়োজনীয় সমাধান, যখন সমস্ত অপশন পারস্পরিক একচেটিয়া না হয় তখন কার্যকর।


0

নেটের উত্তরটি ভাল তবে আমি এটি ডিআইওয়াই করব would

struct MyOptions : OptionSetType {
    let rawValue: Int

    static let None         = Element(rawValue: 0)
    static let FirstOption  = Element(rawValue: 1 << 0)
    static let SecondOption = Element(rawValue: 1 << 1)
    static let ThirdOption  = Element(rawValue: 1 << 2)
}

0

একটি বিকল্প সেট টাইপ ব্যবহার করুন, দ্রুত 3 ব্যবহারে OptionSet

struct ShippingOptions: OptionSet {
    let rawValue: Int

    static let nextDay    = ShippingOptions(rawValue: 1 << 0)
    static let secondDay  = ShippingOptions(rawValue: 1 << 1)
    static let priority   = ShippingOptions(rawValue: 1 << 2)
    static let standard   = ShippingOptions(rawValue: 1 << 3)

    static let express: ShippingOptions = [.nextDay, .secondDay]
    static let all: ShippingOptions = [.express, .priority, .standard]
}

1
এই বেশী বা কম ইতিমধ্যে মধ্যে আবৃত হয় এই উত্তরটি
পাং
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.