chain of responsibility

main.go

package main

import "fmt"

type Request struct {
    amount int
}

type Handler interface {
    SetNext(handler Handler) Handler
    Handle(request *Request) bool
}

type CreditCardHandler struct {
    next Handler
}

func (cc *CreditCardHandler) SetNext(handler Handler) Handler {
    cc.next = handler
    return handler
}

func (cc *CreditCardHandler) Handle(request *Request) bool {
    if request.amount > 5000 && request.amount < 10000 {
        fmt.Println("credit card handler processed the request")
        return true
    }
    
    if cc.next != nil {
        return cc.next.Handle(request)
    }
    
    fmt.Println("no handler available in creditcard handler")
    return false
}

type BankHandler struct {
    next Handler
}

func (b *BankHandler) SetNext(handler Handler) Handler {
    b.next = handler
    return handler
}

func (b *BankHandler) Handle(req *Request) bool {
    if req.amount < 1000 {
        fmt.Println("bank handler processed the request")
        return true
    }
    
    if b.next != nil {
        return b.next.Handle(req)
    }
    
    return false
}

type LoanHandler struct {
    next Handler
}

func (l *LoanHandler) SetNext(handler Handler) Handler {
    l.next = handler
    return handler
}

func (l *LoanHandler) Handle(req *Request) bool {
    if req.amount >= 10000 {
        fmt.Println("loan handler processed the request")
        return true
    }
    
    if l.next != nil {
        return l.next.Handle(req)
    }
    
    fmt.Println("no handler available in loan handler")
    return false
}

func main() {
    bank := &BankHandler{}
    cc := &CreditCardHandler{}
    loan := &LoanHandler{}
    
    bank.SetNext(cc).SetNext(loan)
    
    if !bank.Handle(&Request{amount: 12000}) {
        fmt.Println("All handlers are busy")
    }
}
// output: loan handler processed the request