OOP parking slot

public interface Permission{
    float getFee(Calendar start, Calendar end);
}

class ParkingLot{

    private list<ParkingSpace> freeRegularSpace;
    private list<ParkingSpace> freeCompactSpace;
    private list<ParkingSpace> freeHandicappedSpace;public ParkingLot();

    public ParkingSpace allocateFreeSpace(ParkingSpaceType pspaceType)
    {
        //get a ParkingSpace from the corresponding free list

switch(pspaceType)
{
case MOTORBIKE:

if(freeRegularSpace.size()==0)

   return null;
Vehicle pspace = new(freeRegularSpace.get(0).getId(),....);
pspace.setStart();

freeRegularSpace.remove(0);

case CAR:
pspace = freeCompactSpace.front();
pspace.setStart();
pspace.setpSpaceType(pspaceType);
pspace.setId(freeCompactSpace.front().getId());

freeCompactSpace.pop_front();
break;

case HANDICAPPED:
pspace = freeHandicappedSpace.front();
pspace.setStart();
pspace.setpSpaceType(pspaceType);
pspace.setId(freeHandicappedSpace.front().getId());

freeHandicappedSpace.pop_front();
break;

default:
throw (std::string("Invalid String"));
}

return pspace;
    }

    public float reclainFreeSpace(ParkingSpace pspace){

        pspace.setEnd();

        //return free space to the list

switch(pspace.getpSpaceType())
{
case MOTORBIKE:
freeRegularSpace.push_back(pspace);
break;

case CAR:
freeCompactSpace.push_back(pspace);
break;

case HANDICAPPED:
freeHandicappedSpace.push_back(pspace);
break;

default:
throw (std::string("Invalid String"));

        return pspace.getFee(perm);
    }

    private Permission perm;
}

class ParkingSpace
{
    enum ParkingSpaceType
    {
        MOTORBIKE, CAR, HANDICAPPED;
    }

    private int id;
    private ParkingSpaceType pspaceType;
    private ParkingMeter meter;

    public ParkingSpace(int id, ParkingSpaceType pspaceType)
    {
        super();
        this.id = id;
        this.pspaceType = pspaceType;
    }

    public int getId()
    {
        return id;
    }

    public ParkingSpaceType getpspaceType()
    {
        return pspaceType;
    }

    private class ParkingMeter{
        public GregorianCalendar start;
        public GregorianCalendar end;
    }

    public void setStart()
    {
        meter.start = new GregorianCalendar();
    }
    public void setEnd()
    {
        meter.end = new GregorianCalendar();
    }

    public float getFee(Permision perm)
    {
        return perm.getFee(meter.start, meter.end);
    }
}

public abstract class Vehicle{
    public boolean park(ParkingLot pLot);
    public boolean unpark(ParkingLot pLot){
        if(pspace != null){
            pLot.reclaimFreeSpace(pspace);
            return true;
        }
        return false;
    };
    private ParkingSpace pspace;
}

public class Motorbike extends Vehicle{
    public boolean park(ParkingLot pLot){
        if((pspace=pLot.allocateFreeSpace(ParkingSpaceType.MOTORBIKE))==null){
            return false;
        }
        return true;
    }
}

public class Cars extends Vehicle{
    public boolean park(ParkingLot pLot){
        if((pspace=pLot.allocateFreeSpace(ParkingSpaceType.CAR))==null){
            return false;
        }
        return true;
    }
}

public class HandicappedCars extends Vehicle{
    public boolean park(ParkingLot pLot){
        if((pspace=pLot.allocateFreeSpace(ParkingSpaceType.HANDICAPPED))==null && (pspace=pLot.getfreeSpace(ParkingSpaceType.CAR))==null){
            return false;
        }
        return true;
    }
}