fn clone()

in proxy_agent/src/key_keeper/key.rs [115:164]

• 50 lines of code
• 5 McCabe index (conditional complexity)

    fn clone(&self) -> Self {
        let rules = self.rules.as_ref().map(|r| AccessControlRules {
            privileges: match r.privileges {
                Some(ref p) => {
                    let mut privileges: Vec<Privilege> = Vec::new();
                    for privilege in p {
                        privileges.push(privilege.clone());
                    }
                    Some(privileges)
                }
                None => None,
            },
            roles: match r.roles {
                Some(ref r) => {
                    let mut roles: Vec<Role> = Vec::new();
                    for role in r {
                        roles.push(role.clone());
                    }
                    Some(roles)
                }
                None => None,
            },
            identities: match r.identities {
                Some(ref i) => {
                    let mut identities: Vec<Identity> = Vec::new();
                    for identity in i {
                        identities.push(identity.clone());
                    }
                    Some(identities)
                }
                None => None,
            },
            roleAssignments: match r.roleAssignments {
                Some(ref r) => {
                    let mut role_assignments: Vec<RoleAssignment> = Vec::new();
                    for role_assignment in r {
                        role_assignments.push(role_assignment.clone());
                    }
                    Some(role_assignments)
                }
                None => None,
            },
        });
        AuthorizationItem {
            defaultAccess: self.defaultAccess.to_string(),
            mode: self.mode.to_string(),
            rules,
            id: self.id.to_string(),
        }
    }