How to sum total the attendance of various age groups in third section of tableview using swift instead of implementing new controller? – Ios swift

You want to move your button actions inside your AdditionalGuestInforTVCell cell class, then use a closure to tell the controller that the value changed.

Use a second UITableViewCell class as your "Total" cell – with two labels, so it looks like this:

When your AdditionalGuestInforTVCell cell tells the controller its value changed, update your data, get the sum of all the "items" and reload the 3rd section.

Here’s a quick example…

First, let’s use a struct to define your data:

struct ItemStruct {
    var itemName: String = ""
    var itemDetails: String = ""
    var itemCount: Int = 0
}

In your controller, we’ll use a var property like this:

// our data is now an Array of ItemStruct Arrays
//  so we'll have one Array per section
var myData: [[ItemStruct]] = []

and we’ll initialize the data like this…

In viewDidLoad():

override func viewDidLoad() {
    super.viewDidLoad()
    
    // all the normal view setup

    myData = getData()
}

func getData() -> [[ItemStruct]] {
    let itemsName = [
        ["Shishu", "Baal", "Kishore", "Tarun", "Yuva", "Jyeshta"],
        ["Shishu", "Baalika", "Kishori", "Taruni", "Yuvati", "Jyeshtaa"],
    ]
    let itemsDetails = [
        ["Below 5 Years - Pre-primary ", "5 to 11 Years - Primary School", "11 to 16 Years - Middle School", "17 to 25 Years - High School/College", "25 to 60 Years - Adults", ">60 Years - Senior citizen"],
        ["Below 5 Years - Pre-primary ", "5 to 11 Years - Primary School", "11 to 16 Years - Middle School", "17 to 25 Years - High School/College", "25 to 60 Years - Adults", ">60 Years - Senior citizen"],
    ]
    
    var tmpArray: [[ItemStruct]] = []
    
    // let's fill our data with names and details
    for (names, details) in zip(itemsName, itemsDetails) {
        var secData: [ItemStruct] = []
        for i in 0..<names.count {
            let d = ItemStruct(itemName: names[i], itemDetails: details[i], itemCount: 0)
            secData.append(d)
        }
        tmpArray.append(secData)
    }
    
    return tmpArray

}

Here’s a complete, runnable example. We create everything via code – no @IBOutlet or @IBAction connections – so all you need to do is assign the custom class of a plain UIViewController as AdditionalGuestInformationVC. I’ve tried to include enough in-line comments in the code to make things clear:

struct ItemStruct {
    var itemName: String = ""
    var itemDetails: String = ""
    var itemCount: Int = 0
}


class TotalCell: UITableViewCell {
    
    var lblTitle = UILabel()
    var lblValue = UILabel()
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        commonInit()
    }
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        commonInit()
    }
    func commonInit() {
        
        // label properties
        lblTitle.text = "Total Attendees:"
        lblValue.textAlignment = .center
        
        // add views to contentView
        [lblTitle, lblValue].forEach { v in
            v.translatesAutoresizingMaskIntoConstraints = false
            contentView.addSubview(v)
        }
        
        // use content view's defaualt margins
        let g = contentView.layoutMarginsGuide
        
        // this avoids autolayout complaints
        let c = lblTitle.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: 0.0)
        c.priority = .required - 1
        
        NSLayoutConstraint.activate([
            
            // Name label Top / Leading
            lblTitle.topAnchor.constraint(equalTo: g.topAnchor, constant: 0.0),
            lblTitle.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 0.0),
            lblTitle.heightAnchor.constraint(equalToConstant: 50.0),
            c,
            
            // Value label Trailing
            lblValue.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: 0.0),
            
            lblValue.widthAnchor.constraint(equalToConstant: 40.0),
            
            // vertically center Value label
            lblValue.centerYAnchor.constraint(equalTo: g.centerYAnchor),
            
        ])
        
    }
    
    func fillData(_ value: Int) {
        lblValue.text = "(value)"
    }
    
}

class AdditionalGuestInforTVCell: UITableViewCell {

    // closure to inform the controller that the count changed
    var countChanged: ((UITableViewCell, Int) -> ())?
    
    var lblName = UILabel()
    var lblDetails = UILabel()
    
    var btnMinus = UIButton()
    var lblValue = UILabel()
    var btnPlus = UIButton()
    
    // we'll automatically update the value label when the count changes
    var currentItemCount: Int = 0 {
        didSet {
            lblValue.text = "(currentItemCount)"
        }
    }
    
    @objc func minusTap() {
        if currentItemCount > 0 {
            // decrement current count
            currentItemCount -= 1
            
            // inform the controller
            countChanged?(self, currentItemCount)
        }
    }
    
    @objc func plusTap() {
        // increment current count
        currentItemCount += 1
        
        // inform the controller
        countChanged?(self, currentItemCount)
    }
    
    // we'll fill the labels from our data struct object
    func fillData(_ data: ItemStruct) {
        lblName.text = "(data.itemName)"
        lblDetails.text = "(data.itemDetails)"
        self.currentItemCount = data.itemCount
    }
    
    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
        super.init(style: style, reuseIdentifier: reuseIdentifier)
        commonInit()
    }
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        commonInit()
    }
    func commonInit() {
        
        // label properties
        lblDetails.font = .systemFont(ofSize: 14.0)
        lblDetails.textColor = .gray
        lblDetails.numberOfLines = 0
        
        lblValue.textAlignment = .center
        
        // button titles
        btnMinus.setTitle("-", for: [])
        btnPlus.setTitle("+", for: [])
        
        // button style
        [btnMinus, btnPlus].forEach { b in
            b.setTitleColor(.black, for: .normal)
            b.setTitleColor(.lightGray, for: .highlighted)
            b.layer.cornerRadius = 6
            b.layer.borderWidth = 1
            b.layer.borderColor = UIColor.lightGray.cgColor
        }
        
        // add views to contentView
        [lblName, lblDetails, btnMinus, lblValue, btnPlus].forEach { v in
            v.translatesAutoresizingMaskIntoConstraints = false
            contentView.addSubview(v)
        }
        
        // use content view's defaualt margins
        let g = contentView.layoutMarginsGuide
        
        // this avoids autolayout complaints
        let c = lblDetails.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: 0.0)
        c.priority = .required - 1
        
        NSLayoutConstraint.activate([
            
            // Name label Top / Leading
            lblName.topAnchor.constraint(equalTo: g.topAnchor, constant: 0.0),
            lblName.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 0.0),
            
            // Details label Top (to Name label Bottom) / Leading / Bottom
            lblDetails.topAnchor.constraint(equalTo: lblName.bottomAnchor, constant: 6.0),
            lblDetails.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 0.0),
            c,

            // plus button Trailing
            btnPlus.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: 0.0),
            
            // Value label Trailing (to Plus button Leading)
            lblValue.trailingAnchor.constraint(equalTo: btnPlus.leadingAnchor, constant: 0.0),
            
            // Minus button Trailing (to Value label Leading)
            btnMinus.trailingAnchor.constraint(equalTo: lblValue.leadingAnchor, constant: 0.0),
            
            // buttons and Value label centered vertically
            btnPlus.centerYAnchor.constraint(equalTo: g.centerYAnchor),
            lblValue.centerYAnchor.constraint(equalTo: g.centerYAnchor),
            btnMinus.centerYAnchor.constraint(equalTo: g.centerYAnchor),
            
            btnMinus.widthAnchor.constraint(equalToConstant: 40.0),
            btnPlus.widthAnchor.constraint(equalTo: btnMinus.widthAnchor),
            lblValue.widthAnchor.constraint(equalTo: btnMinus.widthAnchor),

            // Details label Trailing ("right edge")
            lblDetails.trailingAnchor.constraint(equalTo: btnMinus.leadingAnchor, constant: -8.0),
            
        ])

        btnMinus.addTarget(self, action: #selector(minusTap), for: .touchUpInside)
        btnPlus.addTarget(self, action: #selector(plusTap), for: .touchUpInside)

    }
    
}

class AdditionalGuestInformationVC: UIViewController, UITableViewDelegate, UITableViewDataSource {
    
    let section = ["Male", "Female", "Total"]
    
    var tableView: UITableView!
    
    var myData: [[ItemStruct]] = []

    func getData() -> [[ItemStruct]] {
        let itemsName = [
            ["Shishu", "Baal", "Kishore", "Tarun", "Yuva", "Jyeshta"],
            ["Shishu", "Baalika", "Kishori", "Taruni", "Yuvati", "Jyeshtaa"],
        ]
        let itemsDetails = [
            ["Below 5 Years - Pre-primary ", "5 to 11 Years - Primary School", "11 to 16 Years - Middle School", "17 to 25 Years - High School/College", "25 to 60 Years - Adults", ">60 Years - Senior citizen"],
            ["Below 5 Years - Pre-primary ", "5 to 11 Years - Primary School", "11 to 16 Years - Middle School", "17 to 25 Years - High School/College", "25 to 60 Years - Adults", ">60 Years - Senior citizen"],
        ]
        
        var tmpArray: [[ItemStruct]] = []
        
        // let's fill our data with names and details
        for (names, details) in zip(itemsName, itemsDetails) {
            var secData: [ItemStruct] = []
            for i in 0..<names.count {
                let d = ItemStruct(itemName: names[i], itemDetails: details[i], itemCount: 0)
                secData.append(d)
            }
            tmpArray.append(secData)
        }
        
        return tmpArray

    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        view.backgroundColor = .systemGreen
        
        tableView = UITableView(frame: .zero, style: .insetGrouped)
        
        tableView.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(tableView)
        
        let g = view.safeAreaLayoutGuide
        NSLayoutConstraint.activate([
            
            // Top / Leading / Trailing inset by 20-points (so we can see the table frame)
            tableView.topAnchor.constraint(equalTo: g.topAnchor, constant: 20.0),
            tableView.leadingAnchor.constraint(equalTo: g.leadingAnchor, constant: 20.0),
            tableView.trailingAnchor.constraint(equalTo: g.trailingAnchor, constant: -20.0),
            
            // let's leave some space at the bottom
            tableView.bottomAnchor.constraint(equalTo: g.bottomAnchor, constant: -80.0),
            
        ])
        
        // register the "input" cells
        tableView.register(AdditionalGuestInforTVCell.self, forCellReuseIdentifier: "AdditionalGuestInforTVCell")
        // register the "Total" cell
        tableView.register(TotalCell.self, forCellReuseIdentifier: "totalCell")
        
        tableView.dataSource = self
        tableView.delegate = self

        myData = getData()
        
    }

    // MARK: TableView Methods
    
    func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
        return self.section[section]
    }
    
    func numberOfSections(in tableView: UITableView) -> Int {
        // add 1 for the Total section
        return myData.count + 1
    }
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        // if it's the last section, it's the Total section
        if section == myData.count {
            return 1
        }
        return myData[section].count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        
        // if it's the last section, it's the Total section
        if indexPath.section == myData.count {
            let cell = tableView.dequeueReusableCell(withIdentifier: "totalCell", for: indexPath) as! TotalCell
            
            // get the total of values from all data
            var total: Int = 0
            for i in 0..<self.myData.count {
                total += self.myData[i].reduce(0) { $0 + $1.itemCount }
            }
            
            cell.fillData(total)
            
            return cell
        }
        
        // it's not the last section
        
        let cell = tableView.dequeueReusableCell(withIdentifier: "AdditionalGuestInforTVCell", for: indexPath) as! AdditionalGuestInforTVCell
        cell.fillData(myData[indexPath.section][indexPath.row])
        
        // add closure
        cell.countChanged = { [weak self] aCell, aValue in
            guard let self = self,
                  let thisCell = aCell as? AdditionalGuestInforTVCell,
                  let idxPath = self.tableView.indexPath(for: thisCell)
            else { return }
            
            // update the data
            self.myData[idxPath.section][idxPath.row].itemCount = aValue
            
            // reload the last section (the "Total" section)
            self.tableView.reloadSections([self.myData.count], with: .none)
            
        }
        return cell

    }
    
}

and it should look like this when running: