new_base.puml

Composition *--
Aggregation o--
Extension <|--
Instantiates -. >

' ---Class name overview

' ---Car related classes---

abstract class Car{}
    class CabrioCar{}
    class TankCar{}
    class CrossoverCar{}
    class SedanCar{}
    class SUVCar{}


interface Armoring{}
    class BombproofArmoring extends Armoring{}
    class ElectronicArmoring extends Armoring{}
    class GasResistantArmoring extends Armoring{}
    class BulletproofArmoring extends Armoring{}

(?)interface ArmoredParts implements Part, Armoring{}
interface Part{}
    interface Engine implements Part{}
        abstract class LiquidEngine implements Engine{}
            class PetrolEngine extends LiquidEngine{}
            class DieselEgine extends LiquidEngine{}
        abstract class GaseousEngine implements Engine{}
            class LNGEngine extends GaseousEngine{}
            class HydrogenEngine extends GaseousEngine{}
        class ElectricEngine implements Engine{}   
        
    interface FuelStorage implements Part{}
        class LiquidFuelStorage implements FuelStorage{}
        class GaseousFuelStorage implements FuelStorage{}
        class ElectricFuelStorage implements FuelStorage{}
    ' Extra's
    interface Rim implements Part{}
        class DefaultRim implements Rim{}
        class ChromeRim implements Rim{}
    interface Seat implements Part{}
        class FabricSeat implements Seat{}
        class LeatherSet implements Set{}
    
    

interface Fuel{}
    abstract class LiquidFuel implements Fuel{}
        class PetrolLiquidFuel extends LiquidFuel{}
        class ieselLiquidFuel extends LiquidFuel{}
    abstract class GaseousFuel implements Fuel{}
        class LNGGaseousFuel extends GaseousFuel{}
        class HydrogenGaseousFuel extends GaseousFuel{}
    class ElectricFuel implements Fuel{}

' ---Factory classes

class Factory implements Owner{}

' ---AbstractFactory class


interface DriveFactory
    class ElectricDriveFactory implements CarFactory{}
    class DieselDriveFactory implements CarFactory{}
    class LNGDriveFactory implements CarFactory{}
    class HydrogenDriveFactory implements CarFactory{}

interface CarFactory
    class SUVCarFactory implements CarFactory{}
    class CabrioCarFactory implements CarFactory{}
    class CrossoverCarFactory implements CarFactory{}
    class SedanCarFactory implements CarFactory{}

' ---Dealer classes

class Dealer implements Owner{}

' ---Customer classes

class Customer implements Owner{}


' ---Helper classes

interface Owner{}

interface Order{}
    class CarOrder implements Order{}
    class FactoryOrder implements Order{}
    class PartOrder implements Order{}



@startuml

' ---Visual effects

skinparam SequenceMessageTextAlignment center
skinparam SequenceMessageAlignment center

skinparam rectangleBorderThickness 1
skinparam defaultTextAlignment center
skinparam lifelineStrategy solid

skinparam wrapMessageWidth 100

' left to right direction
skinparam linetype polyline
skinparam linetype ortho

' ---Dark mode

' skinparam monochrome reverse

' ---Car classes

together $vehicle {
abstract class Vehicle{
    - Owner owner

    - nrOfSeats : int
    - nrOfDoors : int
    + Vehicle(driveTrain : DriveTrain)

    - Part[] parts
    - FuelStorage[] fuel
    - Armoring armor
    - DriveTrain driveTrain

    rangeLeft()
    fill(Fuel)
    + drive()
    + brake()

    removePart(Part)
    addPart(Part)
}
    class Cabrio extends CivilCar{
        openroof()
        closeroof()
    }
    class F1 extends RaceCar{}
    class Nascar extends RaceCar{}
    class InfantryTank extends Tank{}
    class Sedan extends CivilCar{}
    class SUV extends CivilCar{}

}
abstract class CivilCar extends Vehicle{
    +void print()
}

abstract class Tank extends Vehicle{
    +void print()
}

abstract class RaceCar extends Vehicle{
    +void print()
}

' ---Armoring uses decorator
together $armor{
interface Armoring{
    int health
    activate()
}
    class Armor implements Armoring{
        activate()
    }
    class ArmorDecorator implements Armoring{
        activate(previous)
    }
    class BombproofArmoring extends ArmorDecorator{
        int maxExplosiveForce
        activate()
    }
    class ElectronicArmoring extends ArmorDecorator{
        activate()
    }
    class GasResistantArmoring extends ArmorDecorator{
        activate()
    }
    class BulletproofArmoring extends ArmorDecorator{
        int maxCalibre
        activate()
    }
}

together $part{
interface Part{
    Date made
    +print()

}
    interface Engine implements Part{
        int torque
        int pk

        float efficiency

        insertFuel(Fuel)
    }
        abstract class LiquidEngine implements Engine{
            inject()
        }
            class PetrolEngine extends LiquidEngine{} 
            class DieselEgine extends LiquidEngine{}
        abstract class GaseousEngine implements Engine{
            inject()
        }
            class LNGEngine extends GaseousEngine{}
            class HydrogenEngine extends GaseousEngine{}
        class ElectricEngine implements Engine{
            regen()
        } 
    interface FuelStorage implements Part{
        Fuel[] fuel
        float capacity

        bool checkFuel(Fuel f)
        bool checkFull()
        removeFuel(float a)
        addFuel(Fuel f)
    }
        class LiquidFuelStorage implements FuelStorage{
            LiquidFuel[] fuel
        }
        class GaseousFuelStorage implements FuelStorage{
            GaseousFuel[] fuel
        }
        class ElectricFuelStorage implements FuelStorage{
            ElectricFuel[] fuel
            float minVolt
            float maxVolt
            float minAmpere
            float maxAmpere
        }
    interface Rim implements Part{}
        class DefaultRim implements Rim{}
        class ChromeRim implements Rim{}
    interface Seat implements Part{}
        class FabricSeat implements Seat{}
        class LeatherSeat implements Seat{}
    
}

together $DriveTrain {
class DriveTrain{
    -Engine engine
    -FuelStorage storage

    +accelerate() 
    +fill(Fuel)
}

}

together $fuel {
interface Fuel{
    float kwh
    float amount

    use(float amount)
}
    abstract class LiquidFuel implements Fuel{
        float litre
    }
        class PetrolLiquidFuel extends LiquidFuel{}
        class DieselLiquidFuel extends LiquidFuel{}
    abstract class GaseousFuel implements Fuel{
        float litre
    }
        class LNGGaseousFuel extends GaseousFuel{}
        class HydrogenGaseousFuel extends GaseousFuel{}
    class ElectricFuel implements Fuel{
        float volt
        float ampere
    }  
}
' ---Factory classes

together $market{
class Factory implements Owner{
    FactoryOrder[] incoming_orders
    Part[] parts
    Vehicle[] unfinished_vehicles

    makePart()
    makeVehicle()

    buyPart()
    sellPart()
}

interface DriveFactory{
    +makeEngine()
    +makeFuelStorage()
    +makeDriveTrain()
}
    class ElectricDriveFactory implements DriveFactory{}
    class DieselDriveFactory implements DriveFactory{}
    class PetrolDriveFactory implements DriveFactory{}
    class LNGDriveFactory implements DriveFactory{}
    class HydrogenDriveFactory implements DriveFactory{}

interface AbstractCarFactory{
    -DriveTrain makeDriveParts()
    -Seat makeSeats()
    -Rim makeRims()
    +Vehicle makeCar()
}
    class SUVCarFactory implements AbstractCarFactory{}
    class CabrioCarFactory implements AbstractCarFactory{}
    class CrossoverCarFactory implements AbstractCarFactory{}
    class SedanCarFactory implements AbstractCarFactory{}

' ---Dealer classes

class Dealer implements Owner{
    -FactoryOrder[] outgoing_orders
    -CarOrder[] incoming_orders
    -Part[] parts
    -list<Vehicle, float price, float discount> discount_car_catalogue
    -list<Vehicle, float price> car_catalogue

    +showCatalogue()
    +showDiscountCatalogue()

    +orderCar()
'    Return the car with added features
    +Vehicle refurbishCar(Vehicle v)

    -changePrice()

}


' ---Customer classes

class Customer implements Owner{
    CarOrder[] outgoing_orders
}


' ---Helpingclasses

interface Owner{
    Vehicle[] Vehicles
    int money

    void sell(Vehicle)
    void buy(Vehicle)
}
}

together $order {
interface Order{
    Owner buyer
    Owner seller

    int price

    Date start
    Date end

    bool completed

    send()
    accept()
}
    class VehicleOrder implements Order{
        Vehicle vehicle
    }
    class FactoryOrder implements Order{
        Vehicle vehicle
        int quantity
    
    class PartOrder implements Order{
        Part part
        int quantity
    }
}

' ---Relations

' ---Market relations

Owner -.> Order : "Makes an order"
Vehicle "0..inf"--o "1" Customer
Vehicle "0..inf"--o "1" Dealer
Vehicle "0..inf"--o "1" Factory
Vehicle <.- Factory : "Produces"
Dealer <.-  Customer : "Buys from"
Dealer -.> Factory : "Buys from"

Vehicle "0..inf" *--o "1" Owner : "has"

' ---Car relations to its parts and features

Vehicle --o Part : "has"
Vehicle --o "0..1" Armoring : "can have"

' ---Fuel relation with Engine

DriveTrain -o "1" Engine
DriveTrain -o "1" FuelStorage 
Engine -o Fuel : "burns"

' ---Fuel relation with FuelStorage

FuelStorage --o Fuel : "stores"

' ---Part relations to the factory

Factory -.> Part : "produces"



' hide $order

@enduml