UML Class Diagrams for Interviews.

# library.py: the library loan, with every relationship the diagram will draw
from abc import ABC, abstractmethod

LOAN_DAYS = 14


class LoanError(Exception):  # inheritance: NoCopyAvailable extends this
    pass


class NoCopyAvailable(LoanError):
    pass


class FinePolicy(ABC):  # an interface: the contract a fine rule meets
    @abstractmethod
    def fine(self, days_late: int) -> int: ...


class PerDayFine(FinePolicy):  # realisation: PerDayFine implements FinePolicy
    def __init__(self, rupees_per_day: int) -> None:
        self.rupees_per_day = rupees_per_day

    def fine(self, days_late: int) -> int:
        return self.rupees_per_day * days_late


class BookCopy:
    def __init__(self, barcode: str) -> None:
        self.barcode = barcode


class Book:
    def __init__(self, title: str, barcodes: list) -> None:
        self.title = title
        self.copies = [BookCopy(b) for b in barcodes]  # composition: the book creates and owns its copies


class Member:
    def __init__(self, name: str) -> None:
        self.name = name


class Loan:
    def __init__(self, copy: BookCopy, member: Member, borrowed_day: int) -> None:
        self.copy = copy  # association: a reference to a copy that lives on without the loan
        self.member = member  # association: the same for the member
        self.borrowed_day = borrowed_day

    def fine(self, policy: FinePolicy, returned_day: int) -> int:  # dependency: the policy is only a parameter
        days_late = max(0, returned_day - (self.borrowed_day + LOAN_DAYS))
        return policy.fine(days_late)


class Library:
    def __init__(self) -> None:
        self.books = {}  # composition: the library creates its catalogue...
        self.members = []  # aggregation: ...but members are created elsewhere and only joined
        self.loans = []  # composition: the library creates its loans

    def add_book(self, title: str, barcodes: list) -> None:
        self.books[title] = Book(title, barcodes)

    def join(self, member: Member) -> None:
        self.members.append(member)

    def lend(self, title: str, member: Member, day: int) -> Loan:
        for copy in self.books[title].copies:
            if not any(loan.copy is copy for loan in self.loans):
                loan = Loan(copy, member, day)
                self.loans.append(loan)
                return loan
        raise NoCopyAvailable(f"no free copy of {title}")


library = Library()
library.add_book("Godan", ["G1", "G2"])
asha, ravi, tara = Member("Asha"), Member("Ravi"), Member("Tara")
for member in [asha, ravi, tara]:
    library.join(member)
print(f"Godan has {len(library.books['Godan'].copies)} copies")
first = library.lend("Godan", asha, 1)
print(f"{first.member.name} borrows {first.copy.barcode} on day 1")
second = library.lend("Godan", ravi, 2)
print(f"{second.member.name} borrows {second.copy.barcode} on day 2")
try:
    library.lend("Godan", tara, 3)
except LoanError as e:  # also catches NoCopyAvailable
    print("rejected:", e)
print(f"Asha returns on day 20: fine {first.fine(PerDayFine(2), 20)}")

// LibraryDemo.java: the library loan, with every relationship the diagram will draw
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

class LibraryDemo {
    static final int LOAN_DAYS = 14;

    static class LoanError extends RuntimeException { // inheritance: NoCopyAvailable extends this
        LoanError(String message) { super(message); }
    }

    static class NoCopyAvailable extends LoanError {
        NoCopyAvailable(String message) { super(message); }
    }

    interface FinePolicy { // an interface: the contract a fine rule meets
        int fine(int daysLate);
    }

    static final class PerDayFine implements FinePolicy { // realisation: PerDayFine implements FinePolicy
        private final int rupeesPerDay;

        PerDayFine(int rupeesPerDay) { this.rupeesPerDay = rupeesPerDay; }

        public int fine(int daysLate) { return rupeesPerDay * daysLate; }
    }

    static final class BookCopy {
        final String barcode;

        BookCopy(String barcode) { this.barcode = barcode; }
    }

    static final class Book {
        final String title;
        final List<BookCopy> copies = new ArrayList<>();

        Book(String title, List<String> barcodes) {
            this.title = title;
            for (String b : barcodes) copies.add(new BookCopy(b)); // composition: the book creates and owns its copies
        }
    }

    static final class Member {
        final String name;

        Member(String name) { this.name = name; }
    }

    static final class Loan {
        final BookCopy copy; // association: a reference to a copy that lives on without the loan
        final Member member; // association: the same for the member
        final int borrowedDay;

        Loan(BookCopy copy, Member member, int borrowedDay) { this.copy = copy; this.member = member; this.borrowedDay = borrowedDay; }

        int fine(FinePolicy policy, int returnedDay) { // dependency: the policy is only a parameter
            int daysLate = Math.max(0, returnedDay - (borrowedDay + LOAN_DAYS));
            return policy.fine(daysLate);
        }
    }

    static final class Library {
        final Map<String, Book> books = new LinkedHashMap<>(); // composition: the library creates its catalogue...
        final List<Member> members = new ArrayList<>(); // aggregation: ...but members are created elsewhere and only joined
        final List<Loan> loans = new ArrayList<>(); // composition: the library creates its loans

        void addBook(String title, List<String> barcodes) { books.put(title, new Book(title, barcodes)); }

        void join(Member member) { members.add(member); }

        Loan lend(String title, Member member, int day) {
            for (BookCopy copy : books.get(title).copies) {
                boolean out = loans.stream().anyMatch(l -> l.copy == copy);
                if (!out) {
                    Loan loan = new Loan(copy, member, day);
                    loans.add(loan);
                    return loan;
                }
            }
            throw new NoCopyAvailable("no free copy of " + title);
        }
    }

    public static void main(String[] args) {
        Library library = new Library();
        library.addBook("Godan", List.of("G1", "G2"));
        Member asha = new Member("Asha"), ravi = new Member("Ravi"), tara = new Member("Tara");
        for (Member member : List.of(asha, ravi, tara)) library.join(member);
        System.out.println("Godan has " + library.books.get("Godan").copies.size() + " copies");
        Loan first = library.lend("Godan", asha, 1);
        System.out.println(first.member.name + " borrows " + first.copy.barcode + " on day 1");
        Loan second = library.lend("Godan", ravi, 2);
        System.out.println(second.member.name + " borrows " + second.copy.barcode + " on day 2");
        try {
            library.lend("Godan", tara, 3);
        } catch (LoanError e) { // also catches NoCopyAvailable
            System.out.println("rejected: " + e.getMessage());
        }
        System.out.println("Asha returns on day 20: fine " + first.fine(new PerDayFine(2), 20));
    }
}

// library.cpp: the library loan, with every relationship the diagram will draw
#include <algorithm>
#include <iostream>
#include <map>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

const int LOAN_DAYS = 14;

class LoanError : public std::runtime_error {  // inheritance: NoCopyAvailable extends this
public:
    using std::runtime_error::runtime_error;
};

class NoCopyAvailable : public LoanError {
public:
    using LoanError::LoanError;
};

class FinePolicy {  // an interface: the contract a fine rule meets
public:
    virtual ~FinePolicy() = default;
    virtual int fine(int daysLate) const = 0;
};

class PerDayFine : public FinePolicy {  // realisation: PerDayFine implements FinePolicy
    int rupeesPerDay_;
public:
    explicit PerDayFine(int rupeesPerDay) : rupeesPerDay_(rupeesPerDay) {}
    int fine(int daysLate) const override { return rupeesPerDay_ * daysLate; }
};

struct BookCopy {
    std::string barcode;
};

struct Book {
    std::string title;
    std::vector<BookCopy> copies;  // composition: the copies live inside the book, by value
    Book(std::string t, const std::vector<std::string>& barcodes) : title(std::move(t)) {
        for (const auto& b : barcodes) copies.push_back(BookCopy{b});
    }
};

struct Member {
    std::string name;
};

struct Loan {
    const BookCopy* copy;  // association: a pointer to a copy that lives on without the loan
    const Member* member;  // association: the same for the member
    int borrowedDay;

    int fine(const FinePolicy& policy, int returnedDay) const {  // dependency: the policy is only a parameter
        int daysLate = std::max(0, returnedDay - (borrowedDay + LOAN_DAYS));
        return policy.fine(daysLate);
    }
};

class Library {
public:
    std::map<std::string, Book> books;      // composition: the library creates its catalogue...
    std::vector<const Member*> members;     // aggregation: ...but members are created elsewhere and only joined
    std::vector<Loan> loans;                // composition: the library creates its loans

    void addBook(const std::string& title, const std::vector<std::string>& barcodes) {
        books.emplace(title, Book(title, barcodes));
    }

    void join(const Member& member) { members.push_back(&member); }

    Loan lend(const std::string& title, const Member& member, int day) {
        for (const BookCopy& copy : books.at(title).copies) {
            bool out = std::any_of(loans.begin(), loans.end(), [&](const Loan& l) { return l.copy == &copy; });
            if (!out) {
                loans.push_back(Loan{&copy, &member, day});
                return loans.back();
            }
        }
        throw NoCopyAvailable("no free copy of " + title);
    }
};

int main() {
    Library library;
    library.addBook("Godan", {"G1", "G2"});
    Member asha{"Asha"}, ravi{"Ravi"}, tara{"Tara"};
    for (const Member* member : {&asha, &ravi, &tara}) library.join(*member);
    std::cout << "Godan has " << library.books.at("Godan").copies.size() << " copies\n";
    Loan first = library.lend("Godan", asha, 1);
    std::cout << first.member->name << " borrows " << first.copy->barcode << " on day 1\n";
    Loan second = library.lend("Godan", ravi, 2);
    std::cout << second.member->name << " borrows " << second.copy->barcode << " on day 2\n";
    try {
        library.lend("Godan", tara, 3);
    } catch (const LoanError& e) {  // also catches NoCopyAvailable
        std::cout << "rejected: " << e.what() << "\n";
    }
    std::cout << "Asha returns on day 20: fine " << first.fine(PerDayFine(2), 20) << "\n";
}

// library.js: the library loan, with every relationship the diagram will draw
const LOAN_DAYS = 14;

class LoanError extends Error {} // inheritance: NoCopyAvailable extends this

class NoCopyAvailable extends LoanError {}

// FinePolicy is an interface: any object with fine(daysLate) meets the contract.
// JavaScript has no interfaces, so the contract is the method name.

class PerDayFine { // realisation: PerDayFine meets the FinePolicy contract
  constructor(rupeesPerDay) {
    this.rupeesPerDay = rupeesPerDay;
  }
  fine(daysLate) {
    return this.rupeesPerDay * daysLate;
  }
}

class BookCopy {
  constructor(barcode) {
    this.barcode = barcode;
  }
}

class Book {
  constructor(title, barcodes) {
    this.title = title;
    this.copies = barcodes.map((b) => new BookCopy(b)); // composition: the book creates and owns its copies
  }
}

class Member {
  constructor(name) {
    this.name = name;
  }
}

class Loan {
  constructor(copy, member, borrowedDay) {
    this.copy = copy; // association: a reference to a copy that lives on without the loan
    this.member = member; // association: the same for the member
    this.borrowedDay = borrowedDay;
  }
  fine(policy, returnedDay) { // dependency: the policy is only a parameter
    const daysLate = Math.max(0, returnedDay - (this.borrowedDay + LOAN_DAYS));
    return policy.fine(daysLate);
  }
}

class Library {
  constructor() {
    this.books = new Map(); // composition: the library creates its catalogue...
    this.members = []; // aggregation: ...but members are created elsewhere and only joined
    this.loans = []; // composition: the library creates its loans
  }
  addBook(title, barcodes) {
    this.books.set(title, new Book(title, barcodes));
  }
  join(member) {
    this.members.push(member);
  }
  lend(title, member, day) {
    for (const copy of this.books.get(title).copies) {
      if (!this.loans.some((loan) => loan.copy === copy)) {
        const loan = new Loan(copy, member, day);
        this.loans.push(loan);
        return loan;
      }
    }
    throw new NoCopyAvailable(`no free copy of ${title}`);
  }
}

const library = new Library();
library.addBook("Godan", ["G1", "G2"]);
const [asha, ravi, tara] = [new Member("Asha"), new Member("Ravi"), new Member("Tara")];
for (const member of [asha, ravi, tara]) library.join(member);
console.log(`Godan has ${library.books.get("Godan").copies.length} copies`);
const first = library.lend("Godan", asha, 1);
console.log(`${first.member.name} borrows ${first.copy.barcode} on day 1`);
const second = library.lend("Godan", ravi, 2);
console.log(`${second.member.name} borrows ${second.copy.barcode} on day 2`);
try {
  library.lend("Godan", tara, 3);
} catch (e) {
  if (!(e instanceof LoanError)) throw e; // also matches NoCopyAvailable
  console.log("rejected:", e.message);
}
console.log(`Asha returns on day 20: fine ${first.fine(new PerDayFine(2), 20)}`);

# multiplicity.py: "1..*" and "0..2" on a diagram are rules the code must enforce
class BookCopy:
    def __init__(self, barcode: str) -> None:
        self.barcode = barcode


class Book:
    def __init__(self, title: str, barcodes: list) -> None:
        if len(barcodes) < 1:  # 1..*: a book has at least one copy
            raise ValueError("a book needs at least one copy")
        self.title = title
        self.copies = [BookCopy(b) for b in barcodes]


class Member:
    MAX_LOANS = 2  # 0..2: a member has at most two copies out at a time

    def __init__(self, name: str) -> None:
        self.name = name
        self.on_loan = []

    def borrow(self, copy: BookCopy) -> None:
        if len(self.on_loan) >= Member.MAX_LOANS:
            raise ValueError(f"{self.name} already has {Member.MAX_LOANS} loans (limit {Member.MAX_LOANS})")
        self.on_loan.append(copy)


try:
    Book("Empty", [])
except ValueError as e:
    print("rejected:", e)
godan = Book("Godan", ["G1", "G2", "G3"])
asha = Member("Asha")
asha.borrow(godan.copies[0])
asha.borrow(godan.copies[1])
print(f"Asha has {len(asha.on_loan)} loans")
try:
    asha.borrow(godan.copies[2])
except ValueError as e:
    print("rejected:", e)

// Multiplicity.java: "1..*" and "0..2" on a diagram are rules the code must enforce
import java.util.ArrayList;
import java.util.List;

class Multiplicity {
    static final class BookCopy {
        final String barcode;

        BookCopy(String barcode) { this.barcode = barcode; }
    }

    static final class Book {
        final String title;
        final List<BookCopy> copies = new ArrayList<>();

        Book(String title, List<String> barcodes) {
            if (barcodes.size() < 1) throw new IllegalArgumentException("a book needs at least one copy"); // 1..*
            this.title = title;
            for (String b : barcodes) copies.add(new BookCopy(b));
        }
    }

    static final class Member {
        static final int MAX_LOANS = 2; // 0..2: a member has at most two copies out at a time
        final String name;
        final List<BookCopy> onLoan = new ArrayList<>();

        Member(String name) { this.name = name; }

        void borrow(BookCopy copy) {
            if (onLoan.size() >= MAX_LOANS) {
                throw new IllegalArgumentException(name + " already has " + MAX_LOANS + " loans (limit " + MAX_LOANS + ")");
            }
            onLoan.add(copy);
        }
    }

    public static void main(String[] args) {
        try {
            new Book("Empty", List.of());
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
        Book godan = new Book("Godan", List.of("G1", "G2", "G3"));
        Member asha = new Member("Asha");
        asha.borrow(godan.copies.get(0));
        asha.borrow(godan.copies.get(1));
        System.out.println("Asha has " + asha.onLoan.size() + " loans");
        try {
            asha.borrow(godan.copies.get(2));
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
    }
}

// multiplicity.cpp: "1..*" and "0..2" on a diagram are rules the code must enforce
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

struct BookCopy {
    std::string barcode;
};

struct Book {
    std::string title;
    std::vector<BookCopy> copies;

    Book(std::string t, const std::vector<std::string>& barcodes) : title(std::move(t)) {
        if (barcodes.size() < 1) throw std::invalid_argument("a book needs at least one copy");  // 1..*
        for (const auto& b : barcodes) copies.push_back(BookCopy{b});
    }
};

class Member {
public:
    static const int MAX_LOANS = 2;  // 0..2: a member has at most two copies out at a time
    std::string name;
    std::vector<const BookCopy*> onLoan;

    explicit Member(std::string n) : name(std::move(n)) {}

    void borrow(const BookCopy& copy) {
        if (static_cast<int>(onLoan.size()) >= MAX_LOANS) {
            throw std::invalid_argument(name + " already has " + std::to_string(MAX_LOANS) + " loans (limit " + std::to_string(MAX_LOANS) + ")");
        }
        onLoan.push_back(&copy);
    }
};

int main() {
    try {
        Book("Empty", {});
    } catch (const std::invalid_argument& e) {
        std::cout << "rejected: " << e.what() << "\n";
    }
    Book godan("Godan", {"G1", "G2", "G3"});
    Member asha("Asha");
    asha.borrow(godan.copies[0]);
    asha.borrow(godan.copies[1]);
    std::cout << "Asha has " << asha.onLoan.size() << " loans\n";
    try {
        asha.borrow(godan.copies[2]);
    } catch (const std::invalid_argument& e) {
        std::cout << "rejected: " << e.what() << "\n";
    }
}

// multiplicity.js: "1..*" and "0..2" on a diagram are rules the code must enforce
class BookCopy {
  constructor(barcode) {
    this.barcode = barcode;
  }
}

class Book {
  constructor(title, barcodes) {
    if (barcodes.length < 1) throw new Error("a book needs at least one copy"); // 1..*
    this.title = title;
    this.copies = barcodes.map((b) => new BookCopy(b));
  }
}

class Member {
  static MAX_LOANS = 2; // 0..2: a member has at most two copies out at a time

  constructor(name) {
    this.name = name;
    this.onLoan = [];
  }
  borrow(copy) {
    if (this.onLoan.length >= Member.MAX_LOANS) {
      throw new Error(`${this.name} already has ${Member.MAX_LOANS} loans (limit ${Member.MAX_LOANS})`);
    }
    this.onLoan.push(copy);
  }
}

try {
  new Book("Empty", []);
} catch (e) {
  console.log("rejected:", e.message);
}
const godan = new Book("Godan", ["G1", "G2", "G3"]);
const asha = new Member("Asha");
asha.borrow(godan.copies[0]);
asha.borrow(godan.copies[1]);
console.log(`Asha has ${asha.onLoan.length} loans`);
try {
  asha.borrow(godan.copies[2]);
} catch (e) {
  console.log("rejected:", e.message);
}