ivlevastef / ditranquillity Goto Github PK

builder.register(Card).asSelf()
.initializer { (scope, type) in
  if "gold" == type {
    return GoldCard()
  }
  if "silver" == type {
    return SilverCard()
  }
  return NormalCard()
}
.initializer { (scope) in return NormalCard() }
...
scope.resolve(Card, arg1: "gold") //GoldCard
scope.resolve(Card) //NormalCard

class MyClass {
  private var dependency: IDependency { return lazyDependency.value }
  private let lazyDependency: DILazy<IDependency>
  init(dependency: DILazy<IDependency>) {
    self.lazyDependency= dependency
  }
  func m() {
    self.dependency.method()
  }
}

class MyClass {
  private var dependency: IDependency { return ownedDependency.value }
  private let ownedDependency: DIOwned<IDependency>
  init(dependency: DIOwned<IDependency>) {
    self.ownedDependency= dependency
  }
  func m() {
    self.dependency.method()
  }
}

class A { init(B b) {} } // A requires B
class B { init(A a) {} } // B requires A

builder.register(A).asSelf().initializer { 
  (scope) in A(scope.resolve(B)) 
}
builder.register(B).asSelf().initializer { 
  (scope) in B(scope.resolve(A)) 
}

builder.register(A1).asType(AProtocol)
builder.register(A2).asType(AProtocol)
builder.register(A3).asType(AProtocol)
do {
builder.build() // throw exception: A1,A2,A3 implementation one protocol AProtocol setup default
} catch {
}

class MyClass {
  private let dependency: IDependency
  public init(dependency: IDependency) {
    self.dependency = dependency
  }
}

class MyModule: Module {
  func registate(builder: ComponentBuilder) {
  }
}

builder.registrate(MyModule)

builder.register(Inject).dependency("logger", LoggerProtocol).dependency("service", ServiceProtocol)

builder.register(Inject).dependency{ (scope, inject) in 
  inject.logger = scope.resolve(LoggerProtocol)
  inject.service = scope.resolve(ServiceProtocol)
}

register(UIViewController).asName(pattern: "mainVC").initializer(return MainVC())
register(UIViewController).asName(pattern: "secondVC").initializer(return SecondVC())

class Inject {
  setMain(mainVC: UIViewController) {..}//it's MainVC()
  setSecond(secondVC: UIViewController) {...} //it's SecondVC()
}
...
inject.setMain(scope.resolve("mainVC"))
inject.setSecond(scope.resolve("secondVC"))

builder.registrate(Int).asName("*constName").initializer {_ in 20 }
builder.registrate(Array).asName("constName{Arr|Array}").initializer { _ in [1,2,3,4] }

let constName: Int
let constNameArr: [Int]
init(constName: Int, constNameArr: [Int], secondConstName: Int) {//20, [1,2,3,4], 20
  self.constName = constName
  self.constNameArr = constNameArr
}

buider.registrate(Settings).asSelf().constructor(...).instancePerApp()

class Settings {
  var userColor: String { didSet { save() } }

  func init() {
    userColor = "LoadFrom"
  }

  func save() {
    "SaveTo" = userColor
  }
}

m() {
  let thread1scope = ScopeFabric.createScope()
  thread1scope.bindToThread() // scope bind to thread1
  //or let thread1scope = ScopeFabric.createThreadScope() // scope bind to thread1
  defer {
    thread1scope.unbindFromThread() //scope unbind from thread 1
  }

  let threadScope = ScopeFabric.currentThreadScope() // return thread1scope
  dispatch_async(dispatch_get_other, {
    thread1scope.bindToThread() //scope bind to thread 2
    m1()
    thread1scope.unbindFromThread() //scope unbind from thread 2
  })
 m2()
}

m() {
  let thread1scope = ScopeFabric.createScope()
  thread1scope.bindToThread { (scope) in //bind to thread1
    dispatch_async(dispatch_get_other, {
      scope.bindToThread {
        m1()
      }
   })
   m2()
 } //unbind from thread1
}

builder.registerAny("*Service").asOwn().asTypes("*ServiceProtocol").instancePerScope()

builder.registerAny(UIViewController)
  .asName("firstVC", FirstViewController)
  .asName("secondVC", SecondViewController)
  .asType(ThirdViewController)
  .instancePerDependency()

class MyModule: startupModule {
  func registrate(builder: ComponentBuilder) {
  }
}