code stringlengths 3 1.18M | language stringclasses 1 value |
|---|---|
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.RidePointProviderRemote;
public interface RidePointProviderHome extends BSEntityProviderHome<RidePointProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.RideRoadProviderRemote;
public interface RideRoadProviderHome extends BSEntityProviderHome<RideRoadProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.RoutePointProviderRemote;
public interface RoutePointProviderHome extends BSEntityProviderHome<RoutePointProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.RideProviderRemote;
public interface RideProviderHome extends BSEntityProviderHome<RideProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.TicketProviderRemote;
public interface TicketProviderHome extends BSEntityProviderHome<TicketProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.traffic;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.traffic.RouteProviderRemote;
public interface RouteProviderHome extends BSEntityProviderHome<RouteProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.geography;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.geography.RegionProviderRemote;
public interface RegionProviderHome extends BSEntityProviderHome<RegionProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.geography;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.geography.RoadProviderRemote;
public interface RoadProviderHome extends BSEntityProviderHome<RoadProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.geography;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.geography.StationProviderRemote;
public interface StationProviderHome extends BSEntityProviderHome<StationProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.DriverSkillProviderRemote;
public interface DriverSkillProviderHome extends BSEntityProviderHome<DriverSkillProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.GenericEmployeeProviderRemote;
public interface EmployeeProviderHome extends BSEntityProviderHome<GenericEmployeeProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.MechanicSkillProviderRemote;
public interface MechanicSkillProviderHome extends BSEntityProviderHome<MechanicSkillProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.MechanicProviderRemote;
public interface MechanicProviderHome extends BSEntityProviderHome<MechanicProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.DriverProviderRemote;
public interface DriverProviderHome extends BSEntityProviderHome<DriverProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.staff;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.staff.SalesmanProviderRemote;
public interface SalesmanProviderHome extends BSEntityProviderHome<SalesmanProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.vehicles;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.vehicles.TechnicalStateProviderRemote;
public interface TechnicalStateProviderHome extends BSEntityProviderHome<TechnicalStateProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.vehicles;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.vehicles.BusProviderRemote;
public interface BusProviderHome extends BSEntityProviderHome<BusProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.vehicles;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.vehicles.GasLabelProviderRemote;
public interface GasLabelProviderHome extends BSEntityProviderHome<GasLabelProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.homes.vehicles;
import com.anli.busstation.dal.ejb2.providers.homes.BSEntityProviderHome;
import com.anli.busstation.dal.ejb2.providers.remotes.vehicles.ModelProviderRemote;
public interface ModelProviderHome extends BSEntityProviderHome<ModelProviderRemote> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusService;
public class BusServiceProviderBean extends AbstractBusServiceProviderBean<BusService> {
@Override
protected String getEntityName() {
return "BusService";
}
@Override
public BusService create() {
return null;
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusService;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public abstract class AbstractBusServiceProviderBean<I extends BusService>
extends AbstractTechnicalAssignmentProviderBean<I> {
public List<I> findByBus(Bus bus) {
return getEntityHandler().selectEntitiesByEqualsOrContains("bus", bus);
}
public List<I> findByAnyBus(Collection<Bus> buses) {
return getEntityHandler().selectEntitiesByAny("bus", buses);
}
public List<BigInteger> collectIdsByBus(Bus bus) {
return getEntityHandler().collectKeysByEqualsOrContains("bus", bus);
}
public List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) {
return getEntityHandler().collectKeysByAny("bus", buses);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRepairment;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
public class BusRepairmentProviderBean extends AbstractBusServiceProviderBean<BusRepairment> {
@Override
protected String getEntityName() {
return "BusRepairment";
}
public List<BusRepairment> findByExpendablesPriceRange(BigDecimal expendablesPriceLeft,
boolean strictLeft, BigDecimal expendablesPriceRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("expendablesPrice", expendablesPriceLeft, strictLeft,
expendablesPriceRight, strictRight);
}
public List<BigInteger> collectIdsByExpendablesPriceRange(BigDecimal expendablesPriceLeft,
boolean strictLeft, BigDecimal expendablesPriceRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("expendablesPrice", expendablesPriceLeft, strictLeft,
expendablesPriceRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.maintenance.TechnicalAssignment;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public abstract class AbstractTechnicalAssignmentProviderBean<I extends TechnicalAssignment>
extends AbstractBSProviderBean<I> {
public List<I> findByMechanic(Mechanic mechanic) {
return getEntityHandler().selectEntitiesByEqualsOrContains("mechanic", mechanic);
}
public List<I> findByAnyMechanic(Collection<Mechanic> mechanics) {
return getEntityHandler().selectEntitiesByAny("mechanic", mechanics);
}
public List<I> findByBeginTimeRange(DateTime beginTimeLeft, boolean strictLeft,
DateTime beginTimeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("beginTime", beginTimeLeft, strictLeft,
beginTimeRight, strictRight);
}
public List<I> findByEndTimeRange(DateTime endTimeLeft, boolean strictLeft,
DateTime endTimeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("endTime", endTimeLeft, strictLeft,
endTimeRight, strictRight);
}
public List<I> findByServiceCostRange(BigDecimal serviceCostLeft, boolean strictLeft,
BigDecimal serviceCostRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("serviceCost", serviceCostLeft, strictLeft,
serviceCostRight, strictRight);
}
public List<BigInteger> collectIdsByMechanic(Mechanic mechanic) {
return getEntityHandler().collectKeysByEqualsOrContains("mechanic", mechanic);
}
public List<BigInteger> collectIdsByAnyMechanic(Collection<Mechanic> mechanics) {
return getEntityHandler().collectKeysByAny("mechanic", mechanics);
}
public List<BigInteger> collectIdsByBeginTimeRange(DateTime beginTimeLeft, boolean strictLeft,
DateTime beginTimeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("beginTime", beginTimeLeft, strictLeft,
beginTimeRight, strictRight);
}
public List<BigInteger> collectIdsByEndTimeRange(DateTime endTimeLeft, boolean strictLeft,
DateTime endTimeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("endTime", endTimeLeft, strictLeft,
endTimeRight, strictRight);
}
public List<BigInteger> collectIdsByServiceCostRange(BigDecimal serviceCostLeft, boolean strictLeft,
BigDecimal serviceCostRight, boolean strictRight) throws RemoteException {
return getEntityHandler().collectKeysByRange("serviceCost", serviceCostLeft, strictLeft,
serviceCostRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.TechnicalAssignment;
public class TechnicalAssignmentProviderBean
extends AbstractTechnicalAssignmentProviderBean<TechnicalAssignment> {
@Override
protected String getEntityName() {
return "TechnicalAssignment";
}
@Override
public TechnicalAssignment create() {
return null;
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.StationService;
import java.math.BigInteger;
import java.util.List;
public class StationServiceProviderBean extends AbstractTechnicalAssignmentProviderBean<StationService> {
@Override
protected String getEntityName() {
return "StationService";
}
public List<StationService> findByDescriptionRegexp(String descriptionRegexp) {
return getEntityHandler().selectEntitiesByRegexp("description", descriptionRegexp);
}
public List<BigInteger> collectIdsByDescriptionRegexp(String descriptionRegexp) {
return getEntityHandler().collectKeysByRegexp("description", descriptionRegexp);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRefuelling;
import java.math.BigInteger;
import java.util.List;
public class BusRefuellingProviderBean extends AbstractBusServiceProviderBean<BusRefuelling> {
@Override
protected String getEntityName() {
return "BusRefuelling";
}
public List<BusRefuelling> findByVolumeRange(Integer volumeLeft, boolean strictLeft,
Integer volumeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("volume", volumeLeft, strictLeft,
volumeRight, strictRight);
}
public List<BigInteger> collectIdsByVolumeRange(Integer volumeLeft, boolean strictLeft,
Integer volumeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("volume", volumeLeft, strictLeft,
volumeRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class RideRoadProviderBean extends AbstractBSProviderBean<RideRoad> {
@Override
protected String getEntityName() {
return "RideRoad";
}
public List<RideRoad> findByRoad(Road road) {
return getEntityHandler().selectEntitiesByEqualsOrContains("road", road);
}
public List<RideRoad> findByAnyRoad(Collection<Road> roads) {
return getEntityHandler().selectEntitiesByAny("road", roads);
}
public List<RideRoad> findByDriver(Driver driver) {
return getEntityHandler().selectEntitiesByEqualsOrContains("driver", driver);
}
public List<RideRoad> findByAnyDriver(Collection<Driver> drivers) {
return getEntityHandler().selectEntitiesByAny("driver", drivers);
}
public List<BigInteger> collectIdsByRoad(Road road) {
return getEntityHandler().collectKeysByEqualsOrContains("road", road);
}
public List<BigInteger> collectIdsByAnyRoad(Collection<Road> roads) {
return getEntityHandler().collectKeysByAny("road", roads);
}
public List<BigInteger> collectIdsByDriver(Driver driver) {
return getEntityHandler().collectKeysByEqualsOrContains("driver", driver);
}
public List<BigInteger> collectIdsByAnyDriver(Collection<Driver> drivers) {
return getEntityHandler().collectKeysByAny("driver", drivers);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.Route;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class RouteProviderBean extends AbstractBSProviderBean<Route> {
@Override
protected String getEntityName() {
return "Route";
}
public Route pullRoutePoints(Route route) {
return pullCollection(route, "routePoints");
}
public Route pullRides(Route route) {
return pullCollection(route, "rides");
}
public List<Route> findByNumCode(String numCode) {
return getEntityHandler().selectEntitiesByEqualsOrContains("numCode", numCode);
}
public List<Route> findByAnyNumCode(Collection<String> numCodes) {
return getEntityHandler().selectEntitiesByAny("numCode", numCodes);
}
public List<Route> findByTicketPriceRange(BigDecimal ticketPriceLeft, boolean strictLeft,
BigDecimal ticketPriceRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("ticketPrice", ticketPriceLeft, strictLeft,
ticketPriceRight, strictRight);
}
public List<Route> findByRoutePoint(RoutePoint routePoint) {
return getEntityHandler().selectEntitiesByEqualsOrContains("routePoints", routePoint);
}
public List<Route> findByAnyRoutePoint(Collection<RoutePoint> routePoints) {
return getEntityHandler().selectEntitiesByAny("routePoints", routePoints);
}
public List<Route> findByRide(Ride ride) {
return getEntityHandler().selectEntitiesByEqualsOrContains("rides", ride);
}
public List<Route> findByAnyRide(Collection<Ride> rides) {
return getEntityHandler().selectEntitiesByAny("rides", rides);
}
public List<BigInteger> collectIdsByNumCode(String numCode) {
return getEntityHandler().collectKeysByEqualsOrContains("numCode", numCode);
}
public List<BigInteger> collectIdsByAnyNumCode(Collection<String> numCodes) {
return getEntityHandler().collectKeysByAny("numCode", numCodes);
}
public List<BigInteger> collectIdsByTicketPriceRange(BigDecimal ticketPriceLeft, boolean strictLeft,
BigDecimal ticketPriceRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("ticketPrice", ticketPriceLeft, strictLeft,
ticketPriceRight, strictRight);
}
public List<BigInteger> collectIdsByRoutePoint(RoutePoint routePoint) {
return getEntityHandler().collectKeysByEqualsOrContains("routePoints", routePoint);
}
public List<BigInteger> collectIdsByAnyRoutePoint(Collection<RoutePoint> routePoints) {
return getEntityHandler().collectKeysByAny("routePoints", routePoints);
}
public List<BigInteger> collectIdsByRide(Ride ride) {
return getEntityHandler().collectKeysByEqualsOrContains("rides", ride);
}
public List<BigInteger> collectIdsByAnyRide(Collection<Ride> rides) {
return getEntityHandler().collectKeysByAny("rides", rides);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class RideProviderBean extends AbstractBSProviderBean<Ride> {
@Override
protected String getEntityName() {
return "Ride";
}
public Ride pullRidePoints(Ride ride) {
return pullCollection(ride, "ridePoints");
}
public Ride pullRideRoads(Ride ride) {
return pullCollection(ride, "rideRoads");
}
public Ride pullTickets(Ride ride) {
return pullCollection(ride, "tickets");
}
public List<Ride> findByBus(Bus bus) {
return getEntityHandler().selectEntitiesByEqualsOrContains("bus", bus);
}
public List<Ride> findByAnyBus(Collection<Bus> buses) {
return getEntityHandler().selectEntitiesByAny("bus", buses);
}
public List<Ride> findByRidePoint(RidePoint ridePoint) {
return getEntityHandler().selectEntitiesByEqualsOrContains("ridePoints", ridePoint);
}
public List<Ride> findByAnyRidePoint(Collection<RidePoint> ridePoints) {
return getEntityHandler().selectEntitiesByAny("ridePoints", ridePoints);
}
public List<Ride> findByRideRoad(RideRoad rideRoad) {
return getEntityHandler().selectEntitiesByEqualsOrContains("rideRoads", rideRoad);
}
public List<Ride> findByAnyRideRoad(Collection<RideRoad> rideRoads) {
return getEntityHandler().selectEntitiesByAny("rideRoads", rideRoads);
}
public List<Ride> findByTicket(Ticket ticket) {
return getEntityHandler().selectEntitiesByEqualsOrContains("tickets", ticket);
}
public List<Ride> findByAnyTicket(Collection<Ticket> tickets) {
return getEntityHandler().selectEntitiesByAny("tickets", tickets);
}
public List<BigInteger> collectIdsByBus(Bus bus) {
return getEntityHandler().collectKeysByEqualsOrContains("bus", bus);
}
public List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) {
return getEntityHandler().collectKeysByAny("bus", buses);
}
public List<BigInteger> collectIdsByRidePoint(RidePoint ridePoint) {
return getEntityHandler().collectKeysByEqualsOrContains("ridePoints", ridePoint);
}
public List<BigInteger> collectIdsByAnyRidePoint(Collection<RidePoint> ridePoints) {
return getEntityHandler().collectKeysByAny("ridePoints", ridePoints);
}
public List<BigInteger> collectIdsByRideRoad(RideRoad rideRoad) {
return getEntityHandler().collectKeysByEqualsOrContains("rideRoads", rideRoad);
}
public List<BigInteger> collectIdsByAnyRideRoad(Collection<RideRoad> rideRoads) {
return getEntityHandler().collectKeysByAny("rideRoads", rideRoads);
}
public List<BigInteger> collectIdsByTicket(Ticket ticket) {
return getEntityHandler().collectKeysByEqualsOrContains("tickets", ticket);
}
public List<BigInteger> collectIdsByAnyTicket(Collection<Ticket> tickets) {
return getEntityHandler().collectKeysByAny("tickets", tickets);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public class TicketProviderBean extends AbstractBSProviderBean<Ticket> {
@Override
protected String getEntityName() {
return "Ticket";
}
public List<Ticket> findByDeparturePoint(RidePoint departurePoint) {
return getEntityHandler().selectEntitiesByEqualsOrContains("departurePoint", departurePoint);
}
public List<Ticket> findByAnyDeparturePoint(Collection<RidePoint> departurePoints) {
return getEntityHandler().selectEntitiesByAny("departurePoint", departurePoints);
}
public List<Ticket> findByArrivalPoint(RidePoint arrivalPoint) {
return getEntityHandler().selectEntitiesByEqualsOrContains("arrivalPoint", arrivalPoint);
}
public List<Ticket> findByAnyArrivalPoint(Collection<RidePoint> arrivalPoints) {
return getEntityHandler().selectEntitiesByAny("arrivalPoint", arrivalPoints);
}
public List<Ticket> findBySeat(Integer seat) {
return getEntityHandler().selectEntitiesByEqualsOrContains("seat", seat);
}
public List<Ticket> findBySeatRange(Integer seatLeft, boolean strictLeft,
Integer seatRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("seat", seatLeft, strictLeft,
seatRight, strictRight);
}
public List<Ticket> findBySalesman(Salesman salesman) {
return getEntityHandler().selectEntitiesByEqualsOrContains("salesman", salesman);
}
public List<Ticket> findByAnySalesman(Collection<Salesman> salesmen) {
return getEntityHandler().selectEntitiesByAny("salesman", salesmen);
}
public List<Ticket> findBySaleDateRange(DateTime saleDateLeft, boolean strictLeft,
DateTime saleDateRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("saleDate", saleDateLeft, strictLeft,
saleDateRight, strictRight);
}
public List<Ticket> findByCustomerName(String customerName) {
return getEntityHandler().selectEntitiesByEqualsOrContains("customerName", customerName);
}
public List<Ticket> findByCustomerNameRegexp(String customerNameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("customerName", customerNameRegexp);
}
public List<Ticket> findByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("price", priceLeft, strictLeft,
priceRight, strictRight);
}
public List<Ticket> findBySold(boolean sold) {
return getEntityHandler().selectEntitiesByEqualsOrContains("sold", sold);
}
public List<BigInteger> collectIdsByDeparturePoint(RidePoint departurePoint) {
return getEntityHandler().collectKeysByEqualsOrContains("departurePoint", departurePoint);
}
public List<BigInteger> collectIdsByAnyDeparturePoint(Collection<RidePoint> departurePoints) {
return getEntityHandler().collectKeysByAny("departurePoint", departurePoints);
}
public List<BigInteger> collectIdsByArrivalPoint(RidePoint arrivalPoint) {
return getEntityHandler().collectKeysByEqualsOrContains("arrivalPoint", arrivalPoint);
}
public List<BigInteger> collectIdsByAnyArrivalPoint(Collection<RidePoint> arrivalPoints) {
return getEntityHandler().collectKeysByAny("arrivalPoint", arrivalPoints);
}
public List<BigInteger> collectIdsBySeat(Integer seat) {
return getEntityHandler().collectKeysByEqualsOrContains("seat", seat);
}
public List<BigInteger> collectIdsBySeatRange(Integer seatLeft, boolean strictLeft,
Integer seatRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("seat", seatLeft, strictLeft,
seatRight, strictRight);
}
public List<BigInteger> collectIdsBySalesman(Salesman salesman) {
return getEntityHandler().collectKeysByEqualsOrContains("salesman", salesman);
}
public List<BigInteger> collectIdsByAnySalesman(Collection<Salesman> salesmen) {
return getEntityHandler().collectKeysByAny("salesman", salesmen);
}
public List<BigInteger> collectIdsBySaleDateRange(DateTime saleDateLeft, boolean strictLeft,
DateTime saleDateRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("saleDate", saleDateLeft, strictLeft,
saleDateRight, strictRight);
}
public List<BigInteger> collectIdsByCustomerName(String customerName) {
return getEntityHandler().collectKeysByEqualsOrContains("customerName", customerName);
}
public List<BigInteger> collectIdsByCustomerNameRegexp(String customerNameRegexp) {
return getEntityHandler().collectKeysByRegexp("customerName", customerNameRegexp);
}
public List<BigInteger> collectIdsByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("price", priceLeft, strictLeft,
priceRight, strictRight);
}
public List<BigInteger> collectIdsBySold(boolean sold) {
return getEntityHandler().collectKeysByEqualsOrContains("sold", sold);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public class RidePointProviderBean extends AbstractBSProviderBean<RidePoint> {
@Override
protected String getEntityName() {
return "RidePoint";
}
public List<RidePoint> findByRoutePoint(RoutePoint routePoint) {
return getEntityHandler().selectEntitiesByEqualsOrContains("routePoint", routePoint);
}
public List<RidePoint> findByAnyRoutePoint(Collection<RoutePoint> routePoints) {
return getEntityHandler().selectEntitiesByAny("routePoint", routePoints);
}
public List<RidePoint> findByArrivalTimeRange(DateTime arrivalTimeLeft, boolean strictLeft,
DateTime arrivalTimeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("arrivalTime", arrivalTimeLeft, strictLeft,
arrivalTimeRight, strictRight);
}
public List<RidePoint> findByDepartureTimeRange(DateTime departureTimeLeft, boolean strictLeft,
DateTime departureTimeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("departureTime", departureTimeLeft, strictLeft,
departureTimeRight, strictRight);
}
public List<BigInteger> collectIdsByRoutePoint(RoutePoint routePoint) {
return getEntityHandler().collectKeysByEqualsOrContains("routePoint", routePoint);
}
public List<BigInteger> collectIdsByAnyRoutePoint(Collection<RoutePoint> routePoints) {
return getEntityHandler().collectKeysByAny("routePoint", routePoints);
}
public List<BigInteger> collectIdsByArrivalTimeRange(DateTime arrivalTimeLeft, boolean strictLeft,
DateTime arrivalTimeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("arrivalTime", arrivalTimeLeft, strictLeft,
arrivalTimeRight, strictRight);
}
public List<BigInteger> collectIdsByDepartureTimeRange(DateTime departureTimeLeft, boolean strictLeft,
DateTime departureTimeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("departureTime", departureTimeLeft, strictLeft,
departureTimeRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.traffic;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class RoutePointProviderBean extends AbstractBSProviderBean<RoutePoint> {
@Override
protected String getEntityName() {
return "RoutePoint";
}
public List<RoutePoint> findByStation(Station station) {
return getEntityHandler().selectEntitiesByEqualsOrContains("station", station);
}
public List<RoutePoint> findByAnyStation(Collection<Station> stations) {
return getEntityHandler().selectEntitiesByAny("station", stations);
}
public List<BigInteger> collectIdsByStation(Station station) {
return getEntityHandler().collectKeysByEqualsOrContains("station", station);
}
public List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) {
return getEntityHandler().collectKeysByAny("station", stations);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans;
import com.anli.busstation.dal.exceptions.ConsistencyException;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.sql.configuration.ConfigurationHolder;
import com.anli.busstation.dal.sql.idgeneration.IdGenerator;
import com.anli.simpleorm.exceptions.NonExistentEntitiesException;
import com.anli.simpleorm.handling.EntityHandler;
import java.math.BigInteger;
import java.util.List;
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;
public abstract class AbstractBSProviderBean<I extends BSEntity> implements SessionBean {
protected abstract String getEntityName();
protected EntityHandler<I> getEntityHandler() {
return ConfigurationHolder.getHandlerConfiguration()
.getHandler(getEntityName());
}
protected IdGenerator getIdGenerator() {
return ConfigurationHolder.getIdGenerator();
}
public I create() {
return getEntityHandler().insertEntity(getIdGenerator().generateId());
}
public I save(I entity) {
try {
getEntityHandler().updateEntity(entity);
return entity;
} catch (NonExistentEntitiesException neeException) {
throw new ConsistencyException(neeException.getEntities(), neeException);
}
}
public void remove(I entity) {
try {
getEntityHandler().deleteEntity(entity);
} catch (NonExistentEntitiesException neeException) {
throw new ConsistencyException(neeException.getEntities(), neeException);
}
}
public I findById(BigInteger id) {
return getEntityHandler().selectEntity(id);
}
public List<I> findAll() {
return getEntityHandler().selectAllEntities();
}
public List<BigInteger> collectIdsAll() {
return getEntityHandler().collectAllKeys();
}
protected I pullCollection(I entity, String fieldName) {
try {
getEntityHandler().pullCollection(entity, fieldName);
return entity;
} catch (NonExistentEntitiesException neeException) {
throw new ConsistencyException(neeException.getEntities(), neeException);
}
}
public void ejbCreate() {
}
@Override
public void ejbActivate() {
}
@Override
public void ejbPassivate() {
}
@Override
public void ejbRemove() {
}
@Override
public void setSessionContext(SessionContext context) {
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.geography;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.geography.Region;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public class RegionProviderBean extends AbstractBSProviderBean<Region> {
@Override
protected String getEntityName() {
return "Region";
}
public Region pullStations(Region region) throws RemoteException {
return pullCollection(region, "stations");
}
public List<Region> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<Region> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<Region> findByCode(Integer code) {
return getEntityHandler().selectEntitiesByEqualsOrContains("code", code);
}
public List<Region> findByAnyCode(Collection<Integer> codes) {
return getEntityHandler().selectEntitiesByAny("code", codes);
}
public List<Region> findByStation(Station station) {
return getEntityHandler().selectEntitiesByEqualsOrContains("stations", station);
}
public List<Region> findByAnyStation(Collection<Station> stations) {
return getEntityHandler().selectEntitiesByAny("stations", stations);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsByCode(Integer code) {
return getEntityHandler().collectKeysByEqualsOrContains("code", code);
}
public List<BigInteger> collectIdsByAnyCode(Collection<Integer> codes) {
return getEntityHandler().collectKeysByAny("code", codes);
}
public List<BigInteger> collectIdsByStation(Station station) {
return getEntityHandler().collectKeysByEqualsOrContains("stations", station);
}
public List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) {
return getEntityHandler().collectKeysByAny("stations", stations);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.geography;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class StationProviderBean extends AbstractBSProviderBean<Station> {
@Override
protected String getEntityName() {
return "Station";
}
public Station pullEmployees(Station station) {
return pullCollection(station, "employees");
}
public Station pullBuses(Station station) {
return pullCollection(station, "buses");
}
public List<Station> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<Station> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<Station> findByLatitudeRange(BigDecimal latitudeLeft, boolean strictLeft,
BigDecimal latitudeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("latitude", latitudeLeft,
strictLeft, latitudeRight, strictRight);
}
public List<Station> findByLongitudeRange(BigDecimal longitudeLeft, boolean strictLeft,
BigDecimal longitudeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("longitude", longitudeLeft,
strictLeft, longitudeRight, strictRight);
}
public List<Station> findByEmployee(Employee employee) {
return getEntityHandler().selectEntitiesByEqualsOrContains("employees", employee);
}
public List<Station> findByAnyEmployee(Collection<Employee> employees) {
return getEntityHandler().selectEntitiesByAny("employees", employees);
}
public List<Station> findByBus(Bus bus) {
return getEntityHandler().selectEntitiesByEqualsOrContains("buses", bus);
}
public List<Station> findByAnyBus(Collection<Bus> buses) {
return getEntityHandler().selectEntitiesByAny("buses", buses);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsByLatitudeRange(BigDecimal latitudeLeft, boolean strictLeft,
BigDecimal latitudeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("latitude", latitudeLeft, strictLeft,
latitudeRight, strictRight);
}
public List<BigInteger> collectIdsByLongitudeRange(BigDecimal longitudeLeft, boolean strictLeft,
BigDecimal longitudeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("longitude", longitudeLeft, strictLeft,
longitudeRight, strictRight);
}
public List<BigInteger> collectIdsByEmployee(Employee employee) {
return getEntityHandler().collectKeysByEqualsOrContains("employees", employee);
}
public List<BigInteger> collectIdsByAnyEmployee(Collection<Employee> employees) {
return getEntityHandler().collectKeysByAny("employees", employees);
}
public List<BigInteger> collectIdsByBus(Bus bus) {
return getEntityHandler().collectKeysByEqualsOrContains("buses", bus);
}
public List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) {
return getEntityHandler().collectKeysByAny("buses", buses);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.geography;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
public class RoadProviderBean extends AbstractBSProviderBean<Road> {
@Override
protected String getEntityName() {
return "Road";
}
public List<Road> findByAStation(Station aStation) {
return getEntityHandler().selectEntitiesByEqualsOrContains("aStation", aStation);
}
public List<Road> findByAnyAStation(Collection<Station> aStations) {
return getEntityHandler().selectEntitiesByAny("aStation", aStations);
}
public List<Road> findByZStation(Station zStation) {
return getEntityHandler().selectEntitiesByEqualsOrContains("zStation", zStation);
}
public List<Road> findByAnyZStation(Collection<Station> zStations) {
return getEntityHandler().selectEntitiesByAny("zStation", zStations);
}
public List<Road> findByStation(Station station) {
if (station == null) {
return getEntityHandler().selectEntitiesByNamedQuery("byNullStation", null);
}
BigInteger stationId = station.getId();
return getEntityHandler().selectEntitiesByNamedQuery("byStation",
Arrays.asList(stationId, stationId));
}
public List<Road> findByAnyStation(Collection<Station> stations) {
if (stations == null || stations.isEmpty()) {
return Collections.emptyList();
}
Collection<BigInteger> idList = getStationIds(stations);
return getEntityHandler().selectEntitiesByNamedQuery("byAnyStation",
Arrays.asList(idList, idList));
}
public List<Road> findByLengthRange(Integer lengthLeft, boolean strictLeft,
Integer lengthRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("length", lengthLeft, strictLeft,
lengthRight, strictRight);
}
public List<Road> findByRidePriceRange(BigDecimal ridePriceLeft, boolean strictLeft,
BigDecimal ridePriceRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("ridePrice", ridePriceLeft, strictLeft,
ridePriceRight, strictRight);
}
public List<BigInteger> collectIdsByAStation(Station aStation) {
return getEntityHandler().collectKeysByEqualsOrContains("aStation", aStation);
}
public List<BigInteger> collectIdsByAnyAStation(Collection<Station> aStations) {
return getEntityHandler().collectKeysByAny("aStation", aStations);
}
public List<BigInteger> collectIdsByZStation(Station zStation) {
return getEntityHandler().collectKeysByEqualsOrContains("zStation", zStation);
}
public List<BigInteger> collectIdsByAnyZStation(Collection<Station> zStations) {
return getEntityHandler().collectKeysByAny("zStation", zStations);
}
public List<BigInteger> collectIdsByStation(Station station) {
if (station == null) {
return getEntityHandler().collectKeysByNamedQuery("byNullStation", null);
}
BigInteger stationId = station.getId();
return getEntityHandler().collectKeysByNamedQuery("byStation",
Arrays.asList(stationId, stationId));
}
public List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) {
if (stations == null || stations.isEmpty()) {
return Collections.emptyList();
}
Collection<BigInteger> idList = getStationIds(stations);
return getEntityHandler().collectKeysByNamedQuery("byAnyStation",
Arrays.asList(idList, idList));
}
public List<BigInteger> collectIdsByLengthRange(Integer lengthLeft, boolean strictLeft,
Integer lengthRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("length", lengthLeft, strictLeft,
lengthRight, strictRight);
}
public List<BigInteger> collectIdsByRidePriceRange(BigDecimal rPriceLeft, boolean strictLeft,
BigDecimal rPriceRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("ridePrice", rPriceLeft, strictLeft,
rPriceRight, strictRight);
}
protected Collection<BigInteger> getStationIds(Collection<Station> stations) {
ArrayList<BigInteger> stationIds = new ArrayList<>(stations.size());
for (Station station : stations) {
stationIds.add(station != null ? station.getId() : null);
}
return stationIds;
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
import org.joda.time.DateTime;
public abstract class AbstractEmployeeProviderBean<I extends Employee>
extends AbstractBSProviderBean<I> {
public List<I> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<I> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<I> findBySalaryRange(BigDecimal salaryLeft, boolean strictLeft,
BigDecimal salaryRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("salary", salaryLeft, strictLeft,
salaryRight, strictRight);
}
public List<I> findByHiringDateRange(DateTime hiringDateLeft, boolean strictLeft,
DateTime hiringDateRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("hiringDate", hiringDateLeft, strictLeft,
hiringDateRight, strictRight);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsBySalaryRange(BigDecimal salaryLeft, boolean strictLeft,
BigDecimal salaryRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("salary", salaryLeft, strictLeft,
salaryRight, strictRight);
}
public List<BigInteger> collectIdsByHiringDateRange(DateTime hiringDateLeft, boolean strictLeft,
DateTime hiringDateRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("hiringDate", hiringDateLeft, strictLeft,
hiringDateRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
public class EmployeeProviderBean extends AbstractEmployeeProviderBean<Employee> {
@Override
protected String getEntityName() {
return "Employee";
}
@Override
public Employee create() {
return null;
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class MechanicProviderBean extends AbstractEmployeeProviderBean<Mechanic> {
@Override
protected String getEntityName() {
return "Mechanic";
}
public List<Mechanic> findBySkill(MechanicSkill skill) {
return getEntityHandler().selectEntitiesByEqualsOrContains("skill", skill);
}
public List<Mechanic> findByAnySkill(Collection<MechanicSkill> skills) {
return getEntityHandler().selectEntitiesByAny("skill", skills);
}
public List<BigInteger> collectIdsBySkill(MechanicSkill skill) {
return getEntityHandler().collectKeysByEqualsOrContains("skill", skill);
}
public List<BigInteger> collectIdsByAnySkill(Collection<MechanicSkill> skills) {
return getEntityHandler().collectKeysByAny("skill", skills);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
import java.math.BigInteger;
import java.util.List;
public class DriverSkillProviderBean extends AbstractBSProviderBean<DriverSkill> {
@Override
protected String getEntityName() {
return "DriverSkill";
}
public List<DriverSkill> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<DriverSkill> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<DriverSkill> findByMaxRideLengthRange(Integer maxRideLengthLeft, boolean strictLeft,
Integer maxRideLengthRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("maxRideLength", maxRideLengthLeft, strictLeft,
maxRideLengthRight, strictRight);
}
public List<DriverSkill> findByMaxPassengersRange(Integer maxPassengersLeft, boolean strictLeft,
Integer maxPassengersRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("maxPassengers", maxPassengersLeft, strictLeft,
maxPassengersRight, strictRight);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsByMaxRideLengthRange(Integer maxRideLengthLeft, boolean strictLeft,
Integer maxRideLengthRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("maxRideLength", maxRideLengthLeft, strictLeft,
maxRideLengthRight, strictRight);
}
public List<BigInteger> collectIdsByMaxPassengersRange(Integer maxPassengersLeft, boolean strictLeft,
Integer maxPassengersRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("maxPassengers", maxPassengersLeft, strictLeft,
maxPassengersRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class DriverProviderBean extends AbstractEmployeeProviderBean<Driver> {
@Override
protected String getEntityName() {
return "Driver";
}
public List<Driver> findBySkill(DriverSkill skill) {
return getEntityHandler().selectEntitiesByEqualsOrContains("skill", skill);
}
public List<Driver> findByAnySkill(Collection<DriverSkill> skills) {
return getEntityHandler().selectEntitiesByAny("skill", skills);
}
public List<BigInteger> collectIdsBySkill(DriverSkill skill) {
return getEntityHandler().collectKeysByEqualsOrContains("skill", skill);
}
public List<BigInteger> collectIdsByAnySkill(Collection<DriverSkill> skills) {
return getEntityHandler().collectKeysByAny("skill", skills);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
import java.math.BigInteger;
import java.util.List;
public class SalesmanProviderBean extends AbstractEmployeeProviderBean<Salesman> {
@Override
protected String getEntityName() {
return "Salesman";
}
public List<Salesman> findByTotalSalesRange(Integer totalSalesLeft, boolean strictLeft,
Integer totalSalesRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("totalSales", totalSalesLeft, strictLeft,
totalSalesRight, strictRight);
}
public List<BigInteger> collectIdsByTotalSalesRange(Integer totalSalesLeft, boolean strictLeft,
Integer totalSalesRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("totalSales", totalSalesLeft, strictLeft,
totalSalesRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.staff;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
import java.math.BigInteger;
import java.util.List;
public class MechanicSkillProviderBean extends AbstractBSProviderBean<MechanicSkill> {
@Override
protected String getEntityName() {
return "MechanicSkill";
}
public List<MechanicSkill> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<MechanicSkill> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<MechanicSkill> findByMaxDiffLevelRange(Integer maxDiffLevelLeft, boolean strictLeft,
Integer maxDiffLevelRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("maxDiffLevel", maxDiffLevelLeft, strictLeft,
maxDiffLevelRight, strictRight);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsByMaxDiffLevelRange(Integer maxDiffLevelLeft, boolean strictLeft,
Integer maxDiffLevelRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("maxDiffLevel", maxDiffLevelLeft, strictLeft,
maxDiffLevelRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.vehicles;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.vehicles.GasLabel;
import com.anli.busstation.dal.interfaces.entities.vehicles.Model;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class ModelProviderBean extends AbstractBSProviderBean<Model> {
@Override
protected String getEntityName() {
return "Model";
}
public List<Model> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<Model> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<Model> findBySeatsNumberRange(Integer seatsNumberLeft, boolean strictLeft,
Integer seatsNumberRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("seatsNumber", seatsNumberLeft, strictLeft,
seatsNumberRight, strictRight);
}
public List<Model> findByGasLabel(GasLabel gasLabel) {
return getEntityHandler().selectEntitiesByEqualsOrContains("gasLabel", gasLabel);
}
public List<Model> findByAnyGasLabel(Collection<GasLabel> gasLabels) {
return getEntityHandler().selectEntitiesByAny("gasLabel", gasLabels);
}
public List<Model> findByGasRateRange(BigDecimal gasRateLeft, boolean strictLeft,
BigDecimal gasRateRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("gasRate", gasRateLeft, strictLeft,
gasRateRight, strictRight);
}
public List<Model> findByTankVolumeRange(Integer tankVolumeLeft, boolean strictLeft,
Integer tankVolumeRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("tankVolume", tankVolumeLeft, strictLeft,
tankVolumeRight, strictRight);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsBySeatsNumberRange(Integer seatsNumberLeft, boolean strictLeft,
Integer seatsNumberRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("seatsNumber", seatsNumberLeft, strictLeft,
seatsNumberRight, strictRight);
}
public List<BigInteger> collectIdsByGasLabel(GasLabel gasLabel) {
return getEntityHandler().collectKeysByEqualsOrContains("gasLabel", gasLabel);
}
public List<BigInteger> collectIdsByAnyGasLabel(Collection<GasLabel> gasLabels) {
return getEntityHandler().collectKeysByAny("gasLabel", gasLabels);
}
public List<BigInteger> collectIdsByGasRateRange(BigDecimal gasRateLeft, boolean strictLeft,
BigDecimal gasRateRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("gasRate", gasRateLeft, strictLeft,
gasRateRight, strictRight);
}
public List<BigInteger> collectIdsByTankVolumeRange(Integer tankVolumeLeft, boolean strictLeft,
Integer tankVolumeRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("tankVolume", tankVolumeLeft, strictLeft,
tankVolumeRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.vehicles;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.vehicles.Model;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
import java.math.BigInteger;
import java.util.Collection;
import java.util.List;
public class BusProviderBean extends AbstractBSProviderBean<Bus> {
@Override
protected String getEntityName() {
return "Bus";
}
public List<Bus> findByModel(Model model) {
return getEntityHandler().selectEntitiesByEqualsOrContains("model", model);
}
public List<Bus> findByAnyModel(Collection<Model> models) {
return getEntityHandler().selectEntitiesByAny("model", models);
}
public List<Bus> findByState(TechnicalState state) {
return getEntityHandler().selectEntitiesByEqualsOrContains("state", state);
}
public List<Bus> findByAnyState(Collection<TechnicalState> states) {
return getEntityHandler().selectEntitiesByAny("state", states);
}
public List<Bus> findByPlate(String plate) {
return getEntityHandler().selectEntitiesByEqualsOrContains("plate", plate);
}
public List<BigInteger> collectIdsByModel(Model model) {
return getEntityHandler().collectKeysByEqualsOrContains("model", model);
}
public List<BigInteger> collectIdsByAnyModel(Collection<Model> models) {
return getEntityHandler().collectKeysByAny("model", models);
}
public List<BigInteger> collectIdsByState(TechnicalState state) {
return getEntityHandler().collectKeysByEqualsOrContains("state", state);
}
public List<BigInteger> collectIdsByAnyState(Collection<TechnicalState> states) {
return getEntityHandler().collectKeysByAny("state", states);
}
public List<BigInteger> collectIdsByPlate(String plate) {
return getEntityHandler().collectKeysByEqualsOrContains("plate", plate);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.vehicles;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.vehicles.GasLabel;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.List;
public class GasLabelProviderBean extends AbstractBSProviderBean<GasLabel> {
@Override
protected String getEntityName() {
return "GasLabel";
}
public List<GasLabel> findByName(String name) {
return getEntityHandler().selectEntitiesByEqualsOrContains("name", name);
}
public List<GasLabel> findByNameRegexp(String nameRegexp) {
return getEntityHandler().selectEntitiesByRegexp("name", nameRegexp);
}
public List<GasLabel> findByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("price", priceLeft, strictLeft,
priceRight, strictRight);
}
public List<BigInteger> collectIdsByName(String name) {
return getEntityHandler().collectKeysByEqualsOrContains("name", name);
}
public List<BigInteger> collectIdsByNameRegexp(String nameRegexp) {
return getEntityHandler().collectKeysByRegexp("name", nameRegexp);
}
public List<BigInteger> collectIdsByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("price", priceLeft, strictLeft,
priceRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.beans.vehicles;
import com.anli.busstation.dal.ejb2.providers.beans.AbstractBSProviderBean;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
import java.math.BigInteger;
import java.util.List;
public class TechnicalStateProviderBean extends AbstractBSProviderBean<TechnicalState> {
@Override
protected String getEntityName() {
return "TechnicalState";
}
public List<TechnicalState> findByDescriptionRegexp(String descriptionRegexp) {
return getEntityHandler().selectEntitiesByRegexp("description", descriptionRegexp);
}
public List<TechnicalState> findByDifficultyLevel(Integer difficultyLevel) {
return getEntityHandler().selectEntitiesByEqualsOrContains("difficultyLevel", difficultyLevel);
}
public List<TechnicalState> findByDifficultyLevelRange(Integer difficultyLevelLeft, boolean strictLeft,
Integer difficultyLevelRight, boolean strictRight) {
return getEntityHandler().selectEntitiesByRange("difficultyLevel", difficultyLevelLeft, strictLeft,
difficultyLevelRight, strictRight);
}
public List<BigInteger> collectIdsByDescriptionRegexp(String descriptionRegexp) {
return getEntityHandler().collectKeysByRegexp("description", descriptionRegexp);
}
public List<BigInteger> collectIdsByDifficultyLevel(Integer difficultyLevel) {
return getEntityHandler().collectKeysByEqualsOrContains("difficultyLevel", difficultyLevel);
}
public List<BigInteger> collectIdsByDifficultyLevelRange(Integer difficultyLevelLeft, boolean strictLeft,
Integer difficultyLevelRight, boolean strictRight) {
return getEntityHandler().collectKeysByRange("difficultyLevel", difficultyLevelLeft, strictLeft,
difficultyLevelRight, strictRight);
}
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRefuelling;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface BusRefuellingProviderRemote extends GenericBusServiceProviderRemote<BusRefuelling> {
List<BusRefuelling> findByVolumeRange(Integer volumeLeft, boolean strictLeft,
Integer volumeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByVolumeRange(Integer volumeLeft, boolean strictLeft,
Integer volumeRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.maintenance.TechnicalAssignment;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public interface GenericTechnicalAssignmentProviderRemote<I extends TechnicalAssignment> extends BSEntityProviderRemote<I> {
List<I> findByMechanic(Mechanic mechanic) throws RemoteException;
List<I> findByAnyMechanic(Collection<Mechanic> mechanics) throws RemoteException;
List<I> findByBeginTimeRange(DateTime beginTimeLeft, boolean strictLeft,
DateTime beginTimeRight, boolean strictRight) throws RemoteException;
List<I> findByEndTimeRange(DateTime endTimeLeft, boolean strictLeft,
DateTime endTimeRight, boolean strictRight) throws RemoteException;
List<I> findByServiceCostRange(BigDecimal serviceCostLeft, boolean strictLeft,
BigDecimal serviceCostRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByMechanic(Mechanic mechanic) throws RemoteException;
List<BigInteger> collectIdsByAnyMechanic(Collection<Mechanic> mechanics) throws RemoteException;
List<BigInteger> collectIdsByBeginTimeRange(DateTime beginTimeLeft, boolean strictLeft,
DateTime beginTimeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByEndTimeRange(DateTime endTimeLeft, boolean strictLeft,
DateTime endTimeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByServiceCostRange(BigDecimal serviceCostLeft, boolean strictLeft,
BigDecimal serviceCostRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.TechnicalAssignment;
public interface TechnicalAssignmentProviderRemote extends
GenericTechnicalAssignmentProviderRemote<TechnicalAssignment> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRepairment;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface BusRepairmentProviderRemote extends GenericBusServiceProviderRemote<BusRepairment> {
List<BusRepairment> findByExpendablesPriceRange(BigDecimal expendablesPriceLeft, boolean strictLeft,
BigDecimal expendablesPriceRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByExpendablesPriceRange(BigDecimal expendablesPriceLeft, boolean strictLeft,
BigDecimal expendablesPriceRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusService;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface GenericBusServiceProviderRemote<I extends BusService> extends GenericTechnicalAssignmentProviderRemote<I> {
List<I> findByBus(Bus bus) throws RemoteException;
List<I> findByAnyBus(Collection<Bus> buses) throws RemoteException;
List<BigInteger> collectIdsByBus(Bus bus) throws RemoteException;
List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusService;
public interface BusServiceProviderRemote extends GenericBusServiceProviderRemote<BusService> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.maintenance;
import com.anli.busstation.dal.interfaces.entities.maintenance.StationService;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface StationServiceProviderRemote extends GenericTechnicalAssignmentProviderRemote<StationService> {
List<StationService> findByDescriptionRegexp(String descriptionRegexp) throws RemoteException;
List<BigInteger> collectIdsByDescriptionRegexp(String descriptionRegexp) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
import javax.ejb.EJBObject;
public interface BSEntityProviderRemote<I extends BSEntity> extends EJBObject {
I create() throws RemoteException;
I save(I entity) throws RemoteException;
void remove(I entity) throws RemoteException;
I findById(BigInteger id) throws RemoteException;
List<I> findAll() throws RemoteException;
List<BigInteger> collectIdsAll() throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RideRoadProviderRemote extends BSEntityProviderRemote<RideRoad> {
List<RideRoad> findByRoad(Road road) throws RemoteException;
List<RideRoad> findByAnyRoad(Collection<Road> roads) throws RemoteException;
List<RideRoad> findByDriver(Driver driver) throws RemoteException;
List<RideRoad> findByAnyDriver(Collection<Driver> drivers) throws RemoteException;
List<BigInteger> collectIdsByRoad(Road road) throws RemoteException;
List<BigInteger> collectIdsByAnyRoad(Collection<Road> roads) throws RemoteException;
List<BigInteger> collectIdsByDriver(Driver driver) throws RemoteException;
List<BigInteger> collectIdsByAnyDriver(Collection<Driver> drivers) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.Route;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RouteProviderRemote extends BSEntityProviderRemote<Route> {
Route pullRoutePoints(Route route) throws RemoteException;
Route pullRides(Route route) throws RemoteException;
List<Route> findByNumCode(String numCode) throws RemoteException;
List<Route> findByAnyNumCode(Collection<String> numCodes) throws RemoteException;
List<Route> findByTicketPriceRange(BigDecimal ticketPriceLeft, boolean strictLeft,
BigDecimal ticketPriceRight, boolean strictRight) throws RemoteException;
List<Route> findByRoutePoint(RoutePoint routePoint) throws RemoteException;
List<Route> findByAnyRoutePoint(Collection<RoutePoint> routePoints) throws RemoteException;
List<Route> findByRide(Ride ride) throws RemoteException;
List<Route> findByAnyRide(Collection<Ride> rides) throws RemoteException;
List<BigInteger> collectIdsByNumCode(String numCode) throws RemoteException;
List<BigInteger> collectIdsByAnyNumCode(Collection<String> numCodes) throws RemoteException;
List<BigInteger> collectIdsByTicketPriceRange(BigDecimal ticketPriceLeft, boolean strictLeft,
BigDecimal ticketPriceRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByRoutePoint(RoutePoint routePoint) throws RemoteException;
List<BigInteger> collectIdsByAnyRoutePoint(Collection<RoutePoint> routePoints) throws RemoteException;
List<BigInteger> collectIdsByRide(Ride ride) throws RemoteException;
List<BigInteger> collectIdsByAnyRide(Collection<Ride> rides) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RoutePointProviderRemote extends BSEntityProviderRemote<RoutePoint> {
List<RoutePoint> findByStation(Station station) throws RemoteException;
List<RoutePoint> findByAnyStation(Collection<Station> stations) throws RemoteException;
List<BigInteger> collectIdsByStation(Station station) throws RemoteException;
List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public interface RidePointProviderRemote extends BSEntityProviderRemote<RidePoint> {
List<RidePoint> findByRoutePoint(RoutePoint routePoint) throws RemoteException;
List<RidePoint> findByAnyRoutePoint(Collection<RoutePoint> routePoints) throws RemoteException;
List<RidePoint> findByArrivalTimeRange(DateTime arrivalTimeLeft, boolean strictLeft,
DateTime arrivalTimeRight, boolean strictRight) throws RemoteException;
List<RidePoint> findByDepartureTimeRange(DateTime departureTimeLeft, boolean strictLeft,
DateTime departureTimeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByRoutePoint(RoutePoint routePoint) throws RemoteException;
List<BigInteger> collectIdsByAnyRoutePoint(Collection<RoutePoint> routePoints) throws RemoteException;
List<BigInteger> collectIdsByArrivalTimeRange(DateTime arrivalTimeLeft, boolean strictLeft,
DateTime arrivalTimeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByDepartureTimeRange(DateTime departureTimeLeft, boolean strictLeft,
DateTime departureTimeRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
import org.joda.time.DateTime;
public interface TicketProviderRemote extends BSEntityProviderRemote<Ticket> {
List<Ticket> findByDeparturePoint(RidePoint departurePoint) throws RemoteException;
List<Ticket> findByAnyDeparturePoint(Collection<RidePoint> departurePoints) throws RemoteException;
List<Ticket> findByArrivalPoint(RidePoint arrivalPoint) throws RemoteException;
List<Ticket> findByAnyArrivalPoint(Collection<RidePoint> arrivalPoints) throws RemoteException;
List<Ticket> findBySeat(Integer seat) throws RemoteException;
List<Ticket> findBySeatRange(Integer seatLeft, boolean strictLeft,
Integer seatRight, boolean strictRight) throws RemoteException;
List<Ticket> findBySalesman(Salesman salesman) throws RemoteException;
List<Ticket> findByAnySalesman(Collection<Salesman> salesmen) throws RemoteException;
List<Ticket> findBySaleDateRange(DateTime saleDateLeft, boolean strictLeft,
DateTime saleDateRight, boolean strictRight) throws RemoteException;
List<Ticket> findByCustomerName(String customerName) throws RemoteException;
List<Ticket> findByCustomerNameRegexp(String customerNameRegexp) throws RemoteException;
List<Ticket> findByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) throws RemoteException;
List<Ticket> findBySold(boolean sold) throws RemoteException;
List<BigInteger> collectIdsByDeparturePoint(RidePoint departurePoint) throws RemoteException;
List<BigInteger> collectIdsByAnyDeparturePoint(Collection<RidePoint> departurePoints) throws RemoteException;
List<BigInteger> collectIdsByArrivalPoint(RidePoint arrivalPoint) throws RemoteException;
List<BigInteger> collectIdsByAnyArrivalPoint(Collection<RidePoint> arrivalPoints) throws RemoteException;
List<BigInteger> collectIdsBySeat(Integer seat) throws RemoteException;
List<BigInteger> collectIdsBySeatRange(Integer seatLeft, boolean strictLeft,
Integer seatRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsBySalesman(Salesman salesman) throws RemoteException;
List<BigInteger> collectIdsByAnySalesman(Collection<Salesman> salesmen) throws RemoteException;
List<BigInteger> collectIdsBySaleDateRange(DateTime saleDateLeft, boolean strictLeft,
DateTime saleDateRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByCustomerName(String customerName) throws RemoteException;
List<BigInteger> collectIdsByCustomerNameRegexp(String customerNameRegexp) throws RemoteException;
List<BigInteger> collectIdsByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsBySold(boolean sold) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.traffic;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RideProviderRemote extends BSEntityProviderRemote<Ride> {
Ride pullRidePoints(Ride ride) throws RemoteException;
Ride pullRideRoads(Ride ride) throws RemoteException;
Ride pullTickets(Ride ride) throws RemoteException;
List<Ride> findByBus(Bus bus) throws RemoteException;
List<Ride> findByAnyBus(Collection<Bus> buses) throws RemoteException;
List<Ride> findByRidePoint(RidePoint ridePoint) throws RemoteException;
List<Ride> findByAnyRidePoint(Collection<RidePoint> ridePoints) throws RemoteException;
List<Ride> findByRideRoad(RideRoad rideRoad) throws RemoteException;
List<Ride> findByAnyRideRoad(Collection<RideRoad> rideRoads) throws RemoteException;
List<Ride> findByTicket(Ticket ticket) throws RemoteException;
List<Ride> findByAnyTicket(Collection<Ticket> tickets) throws RemoteException;
List<BigInteger> collectIdsByBus(Bus bus) throws RemoteException;
List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) throws RemoteException;
List<BigInteger> collectIdsByRidePoint(RidePoint ridePoint) throws RemoteException;
List<BigInteger> collectIdsByAnyRidePoint(Collection<RidePoint> ridePoints) throws RemoteException;
List<BigInteger> collectIdsByRideRoad(RideRoad rideRoad) throws RemoteException;
List<BigInteger> collectIdsByAnyRideRoad(Collection<RideRoad> rideRoads) throws RemoteException;
List<BigInteger> collectIdsByTicket(Ticket ticket) throws RemoteException;
List<BigInteger> collectIdsByAnyTicket(Collection<Ticket> tickets) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.geography;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface StationProviderRemote extends BSEntityProviderRemote<Station> {
Station pullEmployees(Station station) throws RemoteException;
Station pullBuses(Station station) throws RemoteException;
List<Station> findByName(String name) throws RemoteException;
List<Station> findByNameRegexp(String nameRegexp) throws RemoteException;
List<Station> findByLatitudeRange(BigDecimal latitudeLeft, boolean strictLeft,
BigDecimal latitudeRight, boolean strictRight) throws RemoteException;
List<Station> findByLongitudeRange(BigDecimal longitudeLeft, boolean strictLeft,
BigDecimal longitudeRight, boolean strictRight) throws RemoteException;
List<Station> findByEmployee(Employee employee) throws RemoteException;
List<Station> findByAnyEmployee(Collection<Employee> employees) throws RemoteException;
List<Station> findByBus(Bus bus) throws RemoteException;
List<Station> findByAnyBus(Collection<Bus> buses) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsByLatitudeRange(BigDecimal latitudeLeft, boolean strictLeft,
BigDecimal latitudeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByLongitudeRange(BigDecimal longitudeLeft, boolean strictLeft,
BigDecimal longitudeRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByEmployee(Employee employee) throws RemoteException;
List<BigInteger> collectIdsByAnyEmployee(Collection<Employee> employees) throws RemoteException;
List<BigInteger> collectIdsByBus(Bus bus) throws RemoteException;
List<BigInteger> collectIdsByAnyBus(Collection<Bus> buses) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.geography;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.geography.Region;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RegionProviderRemote extends BSEntityProviderRemote<Region> {
Region pullStations(Region region) throws RemoteException;
List<Region> findByName(String name) throws RemoteException;
List<Region> findByNameRegexp(String nameRegexp) throws RemoteException;
List<Region> findByCode(Integer code) throws RemoteException;
List<Region> findByAnyCode(Collection<Integer> codes) throws RemoteException;
List<Region> findByStation(Station station) throws RemoteException;
List<Region> findByAnyStation(Collection<Station> stations) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsByCode(Integer code) throws RemoteException;
List<BigInteger> collectIdsByAnyCode(Collection<Integer> codes) throws RemoteException;
List<BigInteger> collectIdsByStation(Station station) throws RemoteException;
List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.geography;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface RoadProviderRemote extends BSEntityProviderRemote<Road> {
List<Road> findByAStation(Station aStation) throws RemoteException;
List<Road> findByAnyAStation(Collection<Station> aStations) throws RemoteException;
List<Road> findByZStation(Station zStation) throws RemoteException;
List<Road> findByAnyZStation(Collection<Station> zStations) throws RemoteException;
List<Road> findByStation(Station station) throws RemoteException;
List<Road> findByAnyStation(Collection<Station> stations) throws RemoteException;
List<Road> findByLengthRange(Integer lengthLeft, boolean strictLeft,
Integer lengthRight, boolean strictRight) throws RemoteException;
List<Road> findByRidePriceRange(BigDecimal ridePriceLeft, boolean strictLeft,
BigDecimal ridePriceRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByAStation(Station aStation) throws RemoteException;
List<BigInteger> collectIdsByAnyAStation(Collection<Station> aStations) throws RemoteException;
List<BigInteger> collectIdsByZStation(Station zStation) throws RemoteException;
List<BigInteger> collectIdsByAnyZStation(Collection<Station> zStations) throws RemoteException;
List<BigInteger> collectIdsByStation(Station station) throws RemoteException;
List<BigInteger> collectIdsByAnyStation(Collection<Station> stations) throws RemoteException;
List<BigInteger> collectIdsByLengthRange(Integer lengthLeft, boolean strictLeft,
Integer lengthRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByRidePriceRange(BigDecimal ridePriceLeft, boolean strictLeft,
BigDecimal ridePriceRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
import org.joda.time.DateTime;
public interface GenericEmployeeProviderRemote<I extends Employee> extends BSEntityProviderRemote<I> {
List<I> findByName(String name) throws RemoteException;
List<I> findByNameRegexp(String nameRegexp) throws RemoteException;
List<I> findBySalaryRange(BigDecimal salaryLeft, boolean strictLeft,
BigDecimal salaryRight, boolean strictRight) throws RemoteException;
List<I> findByHiringDateRange(DateTime hiringDateLeft, boolean strictLeft,
DateTime hiringDateRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsBySalaryRange(BigDecimal salaryLeft, boolean strictLeft,
BigDecimal salaryRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByHiringDateRange(DateTime hiringDateLeft, boolean strictLeft,
DateTime hiringDateRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface SalesmanProviderRemote extends GenericEmployeeProviderRemote<Salesman> {
List<Salesman> findByTotalSalesRange(Integer totalSalesLeft, boolean strictLeft,
Integer totalSalesRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByTotalSalesRange(Integer totalSalesLeft, boolean strictLeft,
Integer totalSalesRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface MechanicProviderRemote extends GenericEmployeeProviderRemote<Mechanic> {
List<Mechanic> findBySkill(MechanicSkill skill) throws RemoteException;
List<Mechanic> findByAnySkill(Collection<MechanicSkill> skills) throws RemoteException;
List<BigInteger> collectIdsBySkill(MechanicSkill skill) throws RemoteException;
List<BigInteger> collectIdsByAnySkill(Collection<MechanicSkill> skills) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface DriverSkillProviderRemote extends BSEntityProviderRemote<DriverSkill> {
List<DriverSkill> findByName(String name) throws RemoteException;
List<DriverSkill> findByNameRegexp(String nameRegexp) throws RemoteException;
List<DriverSkill> findByMaxRideLengthRange(Integer maxRideLengthLeft, boolean strictLeft,
Integer maxRideLengthRight, boolean strictRight) throws RemoteException;
List<DriverSkill> findByMaxPassengersRange(Integer maxPassengersLeft, boolean strictLeft,
Integer maxPassengersRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsByMaxRideLengthRange(Integer maxRideLengthLeft, boolean strictLeft,
Integer maxRideLengthRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByMaxPassengersRange(Integer maxPassengersLeft, boolean strictLeft,
Integer maxPassengersRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface DriverProviderRemote extends GenericEmployeeProviderRemote<Driver> {
List<Driver> findBySkill(DriverSkill skill) throws RemoteException;
List<Driver> findByAnySkill(Collection<DriverSkill> skills) throws RemoteException;
List<BigInteger> collectIdsBySkill(DriverSkill skill) throws RemoteException;
List<BigInteger> collectIdsByAnySkill(Collection<DriverSkill> skills) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface MechanicSkillProviderRemote extends BSEntityProviderRemote<MechanicSkill> {
List<MechanicSkill> findByName(String name) throws RemoteException;
List<MechanicSkill> findByNameRegexp(String nameRegexp) throws RemoteException;
List<MechanicSkill> findByMaxDiffLevelRange(Integer maxDiffLevelLeft, boolean strictLeft,
Integer maxDiffLevelRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsByMaxDiffLevelRange(Integer maxDiffLevelLeft, boolean strictLeft,
Integer maxDiffLevelRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.staff;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
public interface EmployeeProviderRemote extends GenericEmployeeProviderRemote<Employee> {
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.vehicles;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface TechnicalStateProviderRemote extends BSEntityProviderRemote<TechnicalState> {
List<TechnicalState> findByDescriptionRegexp(String descriptionRegexp) throws RemoteException;
List<TechnicalState> findByDifficultyLevel(Integer difficultyLevel) throws RemoteException;
List<TechnicalState> findByDifficultyLevelRange(Integer difficultyLevelLeft, boolean strictLeft,
Integer diffictultyLevelRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByDescriptionRegexp(String descriptionRegexp) throws RemoteException;
List<BigInteger> collectIdsByDifficultyLevel(Integer difficultyLevel) throws RemoteException;
List<BigInteger> collectIdsByDifficultyLevelRange(Integer difficultyLevelLeft, boolean strictLeft,
Integer difficultyLevelRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.vehicles;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.vehicles.Model;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface BusProviderRemote extends BSEntityProviderRemote<Bus> {
List<Bus> findByModel(Model model) throws RemoteException;
List<Bus> findByAnyModel(Collection<Model> models) throws RemoteException;
List<Bus> findByState(TechnicalState state) throws RemoteException;
List<Bus> findByAnyState(Collection<TechnicalState> states) throws RemoteException;
List<Bus> findByPlate(String plate) throws RemoteException;
List<BigInteger> collectIdsByModel(Model model) throws RemoteException;
List<BigInteger> collectIdsByAnyModel(Collection<Model> models) throws RemoteException;
List<BigInteger> collectIdsByState(TechnicalState state) throws RemoteException;
List<BigInteger> collectIdsByAnyState(Collection<TechnicalState> states) throws RemoteException;
List<BigInteger> collectIdsByPlate(String plate) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.vehicles;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.vehicles.GasLabel;
import com.anli.busstation.dal.interfaces.entities.vehicles.Model;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.Collection;
import java.util.List;
public interface ModelProviderRemote extends BSEntityProviderRemote<Model> {
List<Model> findByName(String name) throws RemoteException;
List<Model> findByNameRegexp(String nameRegexp) throws RemoteException;
List<Model> findBySeatsNumberRange(Integer seatsNumberLeft, boolean strictLeft,
Integer seatsNumberRight, boolean strictRight) throws RemoteException;
List<Model> findByTankVolumeRange(Integer tankVolumeLeft, boolean strictLeft,
Integer tankVolumeRight, boolean strictRight) throws RemoteException;
List<Model> findByGasLabel(GasLabel gasLabel) throws RemoteException;
List<Model> findByAnyGasLabel(Collection<GasLabel> gasLabels) throws RemoteException;
List<Model> findByGasRateRange(BigDecimal gasRateLeft, boolean strictLeft,
BigDecimal gasRateRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsBySeatsNumberRange(Integer seatsNumberLeft, boolean strictLeft,
Integer seatsNumberRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByGasLabel(GasLabel gasLabel) throws RemoteException;
List<BigInteger> collectIdsByAnyGasLabel(Collection<GasLabel> gasLabels) throws RemoteException;
List<BigInteger> collectIdsByGasRateRange(BigDecimal gasRateLeft, boolean strictLeft,
BigDecimal gasRateRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByTankVolumeRange(Integer tankVolumeLeft, boolean strictLeft,
Integer tankVolumeRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.providers.remotes.vehicles;
import com.anli.busstation.dal.ejb2.providers.remotes.BSEntityProviderRemote;
import com.anli.busstation.dal.interfaces.entities.vehicles.GasLabel;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.rmi.RemoteException;
import java.util.List;
public interface GasLabelProviderRemote extends BSEntityProviderRemote<GasLabel> {
List<GasLabel> findByName(String name) throws RemoteException;
List<GasLabel> findByNameRegexp(String nameRegexp) throws RemoteException;
List<GasLabel> findByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) throws RemoteException;
List<BigInteger> collectIdsByName(String name) throws RemoteException;
List<BigInteger> collectIdsByNameRegexp(String nameRegexp) throws RemoteException;
List<BigInteger> collectIdsByPriceRange(BigDecimal priceLeft, boolean strictLeft,
BigDecimal priceRight, boolean strictRight) throws RemoteException;
}
| Java |
package com.anli.busstation.dal.ejb2.exceptions;
public class ManualTransactionError extends RuntimeException {
public ManualTransactionError(Throwable cause) {
super(cause);
}
}
| Java |
package com.anli.busstation.dal.ejb2.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
public class EjbExceptionHandler implements InvocationHandler {
protected Object proxied;
protected Collection<Class<? extends Throwable>> manageableExceptions;
public EjbExceptionHandler(Object proxied,
Collection<Class<? extends Throwable>> manageableExceptions) {
this.proxied = proxied;
this.manageableExceptions = manageableExceptions;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Method actualMethod = proxied.getClass().getMethod(method.getName(), method.getParameterTypes());
try {
return actualMethod.invoke(proxied, args);
} catch (InvocationTargetException exception) {
Throwable cause = exception.getCause();
throw getActualException(cause);
}
}
public boolean isManageable(Class<? extends Throwable> exceptionClass) {
for (Class<? extends Throwable> manageable : manageableExceptions) {
if (manageable.isAssignableFrom(exceptionClass)) {
return true;
}
}
return false;
}
public Throwable getActualException(Throwable exception) {
Throwable current = exception;
while (current != null) {
if (isManageable(current.getClass())) {
return current;
}
current = current.getCause();
}
return exception;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import java.math.BigInteger;
import java.util.Iterator;
import java.util.List;
public abstract class BSEntityImpl implements BSEntity {
protected BigInteger id;
@Override
public BigInteger getId() {
return id;
}
public void setId(BigInteger id) {
this.id = id;
}
@Override
public boolean equals(Object comparee) {
if (this.id == null) {
return false;
}
if (comparee == null) {
return false;
}
if (!this.getClass().equals(comparee.getClass())) {
return false;
}
BSEntityImpl compareeEntity = (BSEntityImpl) comparee;
return this.id.equals(compareeEntity.getId());
}
@Override
public int hashCode() {
int hash = 3;
hash = 41 * hash + (this.id != null ? this.id.hashCode() : 0);
return hash;
}
@Deprecated
protected boolean nullableDeepEquals(BSEntityImpl first, BSEntityImpl second) {
if (first != null) {
return first.deepEquals(second);
} else {
return (second == null);
}
}
@Deprecated
protected boolean nullableEquals(Object first, Object second) {
if (first != null) {
return first.equals(second);
} else {
return (second == null);
}
}
@Deprecated
protected boolean nullableEquals(Comparable first, Comparable second) {
if (first != null) {
if (second == null) {
return false;
}
return first.compareTo(second) == 0;
} else {
return (second == null);
}
}
@Deprecated
protected boolean nullableListDeepEquals(List<BSEntityImpl> first, List<BSEntityImpl> second) {
if (first == null && second == null) {
return true;
}
if (first != null && second != null) {
Iterator<BSEntityImpl> firstIter = first.iterator();
Iterator<BSEntityImpl> secondIter = second.iterator();
while (firstIter.hasNext() && secondIter.hasNext()) {
if (!nullableDeepEquals(firstIter.next(), secondIter.next())) {
return false;
}
}
return !firstIter.hasNext() && !secondIter.hasNext();
} else {
return false;
}
}
@Override
public String toString() {
return this.getClass().getSimpleName() + " id = " + id;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.maintenance;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRefuelling;
public class BusRefuellingImpl extends BusServiceImpl implements BusRefuelling {
protected Integer volume;
@Override
public Integer getVolume() {
return volume;
}
@Override
public void setVolume(Integer volume) {
this.volume = volume;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
BusRefuellingImpl brComparee = (BusRefuellingImpl) comparee;
return nullableEquals(this.volume, brComparee.volume);
}
@Override
public String toString() {
return super.toString() + " volume = " + volume;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.maintenance;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.maintenance.StationService;
public class StationServiceImpl extends TechnicalAssignmentImpl implements StationService {
protected String description;
@Override
public String getDescription() {
return description;
}
@Override
public void setDescription(String description) {
this.description = description;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
StationServiceImpl ssComparee = (StationServiceImpl) comparee;
return nullableEquals(this.description, ssComparee.description);
}
@Override
public String toString() {
return super.toString() + " description = " + description;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.maintenance;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusRepairment;
import java.math.BigDecimal;
public class BusRepairmentImpl extends BusServiceImpl implements BusRepairment {
protected BigDecimal expendablesPrice;
@Override
public BigDecimal getExpendablesPrice() {
return expendablesPrice;
}
@Override
public void setExpendablesPrice(BigDecimal expendablesPrice) {
this.expendablesPrice = expendablesPrice;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
BusRepairmentImpl brComparee = (BusRepairmentImpl) comparee;
return nullableEquals(this.expendablesPrice, brComparee.expendablesPrice);
}
@Override
public String toString() {
return super.toString() + " expendablesPrice = " + expendablesPrice;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.maintenance;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.staff.MechanicImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import com.anli.busstation.dal.interfaces.entities.maintenance.TechnicalAssignment;
import java.math.BigDecimal;
import org.joda.time.DateTime;
public abstract class TechnicalAssignmentImpl extends BSEntityImpl implements TechnicalAssignment {
protected MechanicImpl mechanic;
protected DateTime beginTime;
protected DateTime endTime;
protected BigDecimal serviceCost;
@Override
public Mechanic getMechanic() {
return mechanic;
}
@Override
public void setMechanic(Mechanic mechanic) {
this.mechanic = (MechanicImpl) mechanic;
}
@Override
public DateTime getBeginTime() {
return beginTime;
}
@Override
public void setBeginTime(DateTime beginTime) {
this.beginTime = beginTime;
}
@Override
public DateTime getEndTime() {
return endTime;
}
@Override
public void setEndTime(DateTime endTime) {
this.endTime = endTime;
}
@Override
public BigDecimal getServiceCost() {
return serviceCost;
}
@Override
public void setServiceCost(BigDecimal serviceCost) {
this.serviceCost = serviceCost;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
TechnicalAssignmentImpl taComparee = (TechnicalAssignmentImpl) comparee;
return nullableDeepEquals(this.mechanic, taComparee.mechanic)
&& nullableEquals(this.beginTime, taComparee.beginTime)
&& nullableEquals(this.endTime, taComparee.endTime)
&& nullableEquals(this.serviceCost, taComparee.serviceCost);
}
@Override
public String toString() {
return super.toString() + " mechanic = {" + mechanic + "} beginTime = "
+ beginTime + " endTime = " + endTime + " serviceCost = " + serviceCost;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.maintenance;
import com.anli.busstation.dal.ejb2.entities.vehicles.BusImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.maintenance.BusService;
public abstract class BusServiceImpl extends TechnicalAssignmentImpl implements BusService {
protected BusImpl bus;
@Override
public Bus getBus() {
return bus;
}
@Override
public void setBus(Bus bus) {
this.bus = (BusImpl) bus;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
BusServiceImpl bsComparee = (BusServiceImpl) comparee;
return nullableDeepEquals(this.bus, bsComparee.bus);
}
@Override
public String toString() {
return super.toString() + " bus = {" + bus + "}";
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import org.joda.time.DateTime;
public class RidePointImpl extends BSEntityImpl implements RidePoint {
protected RoutePointImpl routePoint;
protected DateTime arrivalTime;
protected DateTime departureTime;
@Override
public RoutePoint getRoutePoint() {
return routePoint;
}
@Override
public void setRoutePoint(RoutePoint routePoint) {
this.routePoint = (RoutePointImpl) routePoint;
}
@Override
public DateTime getArrivalTime() {
return arrivalTime;
}
@Override
public void setArrivalTime(DateTime arrivalTime) {
this.arrivalTime = arrivalTime;
}
@Override
public DateTime getDepartureTime() {
return departureTime;
}
@Override
public void setDepartureTime(DateTime departureTime) {
this.departureTime = departureTime;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RidePointImpl rpComparee = (RidePointImpl) comparee;
return nullableDeepEquals(this.routePoint, rpComparee.routePoint)
&& nullableEquals(this.arrivalTime, rpComparee.arrivalTime)
&& nullableEquals(this.departureTime, rpComparee.departureTime);
}
@Override
public String toString() {
return super.toString() + " routePoint = {" + routePoint + "} arrivalTime = "
+ arrivalTime + " departureTime = " + departureTime;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.staff.SalesmanImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import java.math.BigDecimal;
import org.joda.time.DateTime;
public class TicketImpl extends BSEntityImpl implements Ticket {
protected RidePointImpl departurePoint;
protected RidePointImpl arrivalPoint;
protected Integer seat;
protected SalesmanImpl salesman;
protected DateTime saleDate;
protected String customerName;
protected BigDecimal price;
protected boolean sold;
@Override
public RidePoint getDeparturePoint() {
return departurePoint;
}
@Override
public void setDeparturePoint(RidePoint departurePoint) {
this.departurePoint = (RidePointImpl) departurePoint;
}
@Override
public RidePoint getArrivalPoint() {
return arrivalPoint;
}
@Override
public void setArrivalPoint(RidePoint arrivalPoint) {
this.arrivalPoint = (RidePointImpl) arrivalPoint;
}
@Override
public Integer getSeat() {
return seat;
}
@Override
public void setSeat(Integer seat) {
this.seat = seat;
}
@Override
public Salesman getSalesman() {
return salesman;
}
@Override
public void setSalesman(Salesman salesman) {
this.salesman = (SalesmanImpl) salesman;
}
@Override
public DateTime getSaleDate() {
return saleDate;
}
@Override
public void setSaleDate(DateTime saleDate) {
this.saleDate = saleDate;
}
@Override
public String getCustomerName() {
return customerName;
}
@Override
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
@Override
public BigDecimal getPrice() {
return price;
}
@Override
public void setPrice(BigDecimal price) {
this.price = price;
}
@Override
public boolean isSold() {
return sold;
}
@Override
public void setSold(boolean sold) {
this.sold = sold;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
TicketImpl ticketComparee = (TicketImpl) comparee;
return nullableDeepEquals(this.arrivalPoint, ticketComparee.arrivalPoint)
&& nullableDeepEquals(this.departurePoint, ticketComparee.departurePoint)
&& nullableDeepEquals(this.salesman, ticketComparee.salesman)
&& nullableEquals(this.customerName, ticketComparee.customerName)
&& nullableEquals(this.saleDate, ticketComparee.saleDate)
&& nullableEquals(this.seat, ticketComparee.seat)
&& nullableEquals(this.price, ticketComparee.price)
&& this.sold == ticketComparee.sold;
}
@Override
public String toString() {
return super.toString() + " arrivalPoint = {" + arrivalPoint + "} departurePoint = "
+ departurePoint + "} salesman = {" + salesman + "} customerName = " + customerName
+ " saleDate = " + saleDate + " seat = " + seat + " price = " + price + " sold = " + sold;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.vehicles.BusImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.RidePoint;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import com.anli.busstation.dal.interfaces.entities.traffic.Ticket;
import java.util.List;
public class RideImpl extends BSEntityImpl implements Ride {
protected BusImpl bus;
protected List<RidePointImpl> ridePoints;
protected List<RideRoadImpl> rideRoads;
protected List<TicketImpl> tickets;
@Override
public Bus getBus() {
return bus;
}
@Override
public void setBus(Bus bus) {
this.bus = (BusImpl) bus;
}
@Override
public List<RidePoint> getRidePoints() {
return (List) ridePoints;
}
public void setRidePoints(List<RidePointImpl> ridePoints) {
this.ridePoints = ridePoints;
}
@Override
public List<RideRoad> getRideRoads() {
return (List) rideRoads;
}
public void setRideRoads(List<RideRoadImpl> rideRoads) {
this.rideRoads = rideRoads;
}
@Override
public List<Ticket> getTickets() {
return (List) tickets;
}
public void setTickets(List<TicketImpl> tickets) {
this.tickets = tickets;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RideImpl rideComparee = (RideImpl) comparee;
return nullableDeepEquals(this.bus, rideComparee.bus)
&& nullableListDeepEquals((List) this.ridePoints, (List) rideComparee.ridePoints)
&& nullableListDeepEquals((List) this.rideRoads, (List) rideComparee.rideRoads)
&& nullableListDeepEquals((List) this.tickets, (List) rideComparee.tickets);
}
@Override
public String toString() {
return super.toString() + " bus = {" + bus + "} ridePoints = "
+ ridePoints + " rideRoads = " + rideRoads + " tickets = " + tickets;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.geography.StationImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
public class RoutePointImpl extends BSEntityImpl implements RoutePoint {
protected StationImpl station;
@Override
public Station getStation() {
return station;
}
@Override
public void setStation(Station station) {
this.station = (StationImpl) station;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RoutePointImpl rpComparee = (RoutePointImpl) comparee;
return nullableDeepEquals(this.station, rpComparee.station);
}
@Override
public String toString() {
return super.toString() + " station = {" + station + "}";
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.traffic.Ride;
import com.anli.busstation.dal.interfaces.entities.traffic.Route;
import com.anli.busstation.dal.interfaces.entities.traffic.RoutePoint;
import java.math.BigDecimal;
import java.util.List;
public class RouteImpl extends BSEntityImpl implements Route {
protected String numCode;
protected BigDecimal ticketPrice;
protected List<RoutePointImpl> routePoints;
protected List<RideImpl> rides;
@Override
public String getNumCode() {
return numCode;
}
@Override
public void setNumCode(String numCode) {
this.numCode = numCode;
}
@Override
public BigDecimal getTicketPrice() {
return ticketPrice;
}
@Override
public void setTicketPrice(BigDecimal ticketPrice) {
this.ticketPrice = ticketPrice;
}
@Override
public List<RoutePoint> getRoutePoints() {
return (List) routePoints;
}
public void setRoutePoints(List<RoutePointImpl> routePoint) {
this.routePoints = routePoint;
}
@Override
public List<Ride> getRides() {
return (List) rides;
}
public void setRides(List<RideImpl> rides) {
this.rides = rides;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RouteImpl routeComparee = (RouteImpl) comparee;
return nullableEquals(this.numCode, routeComparee.numCode)
&& nullableEquals(this.ticketPrice, routeComparee.ticketPrice)
&& nullableListDeepEquals((List) this.rides, (List) routeComparee.rides)
&& nullableListDeepEquals((List) this.routePoints, (List) routeComparee.routePoints);
}
@Override
public String toString() {
return super.toString() + " numCode = " + numCode + " ticketPrice = "
+ ticketPrice + " rides = " + rides + " routePoints" + routePoints;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.traffic;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.staff.DriverImpl;
import com.anli.busstation.dal.ejb2.entities.geography.RoadImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.traffic.RideRoad;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
public class RideRoadImpl extends BSEntityImpl implements RideRoad {
protected RoadImpl road;
protected DriverImpl driver;
@Override
public Road getRoad() {
return road;
}
@Override
public void setRoad(Road road) {
this.road = (RoadImpl) road;
}
@Override
public Driver getDriver() {
return driver;
}
@Override
public void setDriver(Driver driver) {
this.driver = (DriverImpl) driver;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RideRoadImpl rrComparee = (RideRoadImpl) comparee;
return nullableDeepEquals(this.driver, rrComparee.driver)
&& nullableDeepEquals(this.road, rrComparee.road);
}
@Override
public String toString() {
return super.toString() + " driver = {" + driver
+ "} road = {" + road + "}";
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.geography;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.ejb2.entities.vehicles.BusImpl;
import com.anli.busstation.dal.ejb2.entities.staff.EmployeeImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigDecimal;
import java.util.List;
public class StationImpl extends BSEntityImpl implements Station {
protected String name;
protected BigDecimal latitude;
protected BigDecimal longitude;
protected List<EmployeeImpl> employees;
protected List<BusImpl> buses;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public BigDecimal getLatitude() {
return latitude;
}
@Override
public void setLatitude(BigDecimal latitude) {
this.latitude = latitude;
}
@Override
public BigDecimal getLongitude() {
return longitude;
}
@Override
public void setLongitude(BigDecimal longitude) {
this.longitude = longitude;
}
@Override
public List<Employee> getEmployees() {
return (List) employees;
}
public void setEmployees(List<EmployeeImpl> employees) {
this.employees = employees;
}
@Override
public List<Bus> getBuses() {
return (List) buses;
}
public void setBuses(List<BusImpl> buses) {
this.buses = buses;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
StationImpl stationComparee = (StationImpl) comparee;
return nullableEquals(this.name, stationComparee.name)
&& nullableEquals(this.latitude, stationComparee.latitude)
&& nullableEquals(this.longitude, stationComparee.longitude)
&& nullableListDeepEquals((List) this.employees, (List) stationComparee.employees)
&& nullableListDeepEquals((List) this.buses, (List) stationComparee.buses);
}
@Override
public String toString() {
return super.toString() + " name = " + name
+ " latitude = " + latitude + " longitude = " + longitude
+ " employees = " + employees + " buses = " + buses;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.geography;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.geography.Region;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.util.List;
public class RegionImpl extends BSEntityImpl implements Region {
protected String name;
protected Integer code;
protected List<StationImpl> stations;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public Integer getCode() {
return code;
}
@Override
public void setCode(Integer code) {
this.code = code;
}
@Override
public List<Station> getStations() {
return (List) stations;
}
public void setStations(List<StationImpl> stations) {
this.stations = stations;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RegionImpl regComparee = (RegionImpl) comparee;
return nullableEquals(this.name, regComparee.name)
&& nullableEquals(this.code, regComparee.code)
&& nullableListDeepEquals((List) this.stations, (List) regComparee.stations);
}
@Override
public String toString() {
return super.toString() + " name = " + name + " code = " + code
+ " stations = " + stations;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.geography;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.geography.Road;
import com.anli.busstation.dal.interfaces.entities.geography.Station;
import java.math.BigDecimal;
public class RoadImpl extends BSEntityImpl implements Road {
protected StationImpl aStation;
protected StationImpl zStation;
protected Integer length;
protected BigDecimal ridePrice;
@Override
public Station getAStation() {
return aStation;
}
@Override
public void setAStation(Station aStation) {
this.aStation = (StationImpl) aStation;
}
@Override
public Station getZStation() {
return zStation;
}
@Override
public void setZStation(Station zStation) {
this.zStation = (StationImpl) zStation;
}
@Override
public Integer getLength() {
return length;
}
@Override
public void setLength(Integer length) {
this.length = length;
}
@Override
public BigDecimal getRidePrice() {
return ridePrice;
}
@Override
public void setRidePrice(BigDecimal ridePrice) {
this.ridePrice = ridePrice;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
RoadImpl roadComparee = (RoadImpl) comparee;
return nullableDeepEquals(this.aStation, roadComparee.aStation)
&& nullableDeepEquals(this.zStation, roadComparee.zStation)
&& nullableEquals(this.length, roadComparee.length)
&& nullableEquals(this.ridePrice, roadComparee.ridePrice);
}
@Override
public String toString() {
return super.toString() + " aStation = {" + aStation + "} zStation = {"
+ zStation + "} length = " + length + " ridePrice = " + ridePrice;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Mechanic;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
public class MechanicImpl extends EmployeeImpl implements Mechanic {
protected MechanicSkillImpl skill;
@Override
public MechanicSkill getSkill() {
return skill;
}
@Override
public void setSkill(MechanicSkill skill) {
this.skill = (MechanicSkillImpl) skill;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
MechanicImpl mechComparee = (MechanicImpl) comparee;
return nullableDeepEquals(this.skill, mechComparee.skill);
}
@Override
public String toString() {
return super.toString() + " skill = {" + skill + "}";
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Salesman;
public class SalesmanImpl extends EmployeeImpl implements Salesman {
protected Integer totalSales;
@Override
public Integer getTotalSales() {
return totalSales;
}
@Override
public void setTotalSales(Integer totalSales) {
this.totalSales = totalSales;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
SalesmanImpl salesComparee = (SalesmanImpl) comparee;
return nullableEquals(this.totalSales, salesComparee.totalSales);
}
@Override
public String toString() {
return super.toString() + " totalSales = " + totalSales;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.MechanicSkill;
public class MechanicSkillImpl extends BSEntityImpl implements MechanicSkill {
protected String name;
protected Integer maxDiffLevel;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public Integer getMaxDiffLevel() {
return maxDiffLevel;
}
@Override
public void setMaxDiffLevel(Integer maxDiffLevel) {
this.maxDiffLevel = maxDiffLevel;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
MechanicSkillImpl msComparee = (MechanicSkillImpl) comparee;
return nullableEquals(this.name, msComparee.name)
&& nullableEquals(this.maxDiffLevel, msComparee.maxDiffLevel);
}
@Override
public String toString() {
return super.toString() + " name = " + name
+ " maxDiffLevel = " + maxDiffLevel;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Employee;
import java.math.BigDecimal;
import org.joda.time.DateTime;
public abstract class EmployeeImpl extends BSEntityImpl implements Employee {
protected String name;
protected BigDecimal salary;
protected DateTime hiringDate;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public BigDecimal getSalary() {
return salary;
}
@Override
public void setSalary(BigDecimal salary) {
this.salary = salary;
}
@Override
public DateTime getHiringDate() {
return hiringDate;
}
@Override
public void setHiringDate(DateTime hiringDate) {
this.hiringDate = hiringDate;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
EmployeeImpl empComparee = (EmployeeImpl) comparee;
return nullableEquals(this.name, empComparee.name)
&& nullableEquals(this.hiringDate, empComparee.hiringDate)
&& nullableEquals(this.salary, empComparee.salary);
}
@Override
public String toString() {
return super.toString() + " name = " + name
+ " salary = " + salary + " hiringDate = " + hiringDate;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
public class DriverSkillImpl extends BSEntityImpl implements DriverSkill {
protected String name;
protected Integer maxRideLength;
protected Integer maxPassengers;
@Override
public String getName() {
return name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public Integer getMaxRideLength() {
return maxRideLength;
}
@Override
public void setMaxRideLength(Integer maxRideLength) {
this.maxRideLength = maxRideLength;
}
@Override
public Integer getMaxPassengers() {
return maxPassengers;
}
@Override
public void setMaxPassengers(Integer maxPassengers) {
this.maxPassengers = maxPassengers;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
DriverSkillImpl dsComparee = (DriverSkillImpl) comparee;
return nullableEquals(this.name, dsComparee.name)
&& nullableEquals(this.maxPassengers, dsComparee.maxPassengers)
&& nullableEquals(this.maxRideLength, dsComparee.maxRideLength);
}
@Override
public String toString() {
return super.toString() + " name = " + name + " maxPassengers = "
+ maxPassengers + " maxRideLength = " + maxRideLength;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.staff;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.staff.Driver;
import com.anli.busstation.dal.interfaces.entities.staff.DriverSkill;
public class DriverImpl extends EmployeeImpl implements Driver {
protected DriverSkillImpl skill;
@Override
public DriverSkill getSkill() {
return skill;
}
@Override
public void setSkill(DriverSkill skill) {
this.skill = (DriverSkillImpl) skill;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!super.deepEquals(comparee)) {
return false;
}
DriverImpl drComparee = (DriverImpl) comparee;
return nullableDeepEquals(this.skill, drComparee.skill);
}
@Override
public String toString() {
return super.toString() + " skill = {" + skill + "}";
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.vehicles;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
public class TechnicalStateImpl extends BSEntityImpl implements TechnicalState {
protected String description;
protected Integer difficultyLevel;
@Override
public String getDescription() {
return description;
}
@Override
public void setDescription(String description) {
this.description = description;
}
@Override
public Integer getDifficultyLevel() {
return difficultyLevel;
}
@Override
public void setDifficultyLevel(Integer difficultyLevel) {
this.difficultyLevel = difficultyLevel;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
TechnicalStateImpl tsComparee = (TechnicalStateImpl) comparee;
return nullableEquals(this.description, tsComparee.description)
&& nullableEquals(this.difficultyLevel, tsComparee.difficultyLevel);
}
@Override
public String toString() {
return super.toString() + " description = " + description
+ " difficultyLevel = " + difficultyLevel;
}
}
| Java |
package com.anli.busstation.dal.ejb2.entities.vehicles;
import com.anli.busstation.dal.ejb2.entities.BSEntityImpl;
import com.anli.busstation.dal.interfaces.entities.BSEntity;
import com.anli.busstation.dal.interfaces.entities.vehicles.Bus;
import com.anli.busstation.dal.interfaces.entities.vehicles.Model;
import com.anli.busstation.dal.interfaces.entities.vehicles.TechnicalState;
public class BusImpl extends BSEntityImpl implements Bus {
protected ModelImpl model;
protected TechnicalStateImpl state;
protected String plate;
@Override
public Model getModel() {
return model;
}
@Override
public void setModel(Model model) {
this.model = (ModelImpl) model;
}
@Override
public TechnicalState getState() {
return state;
}
@Override
public void setState(TechnicalState state) {
this.state = (TechnicalStateImpl) state;
}
@Override
public String getPlate() {
return plate;
}
@Override
public void setPlate(String plate) {
this.plate = plate;
}
@Override
public boolean deepEquals(BSEntity comparee) {
if (!this.equals(comparee)) {
return false;
}
BusImpl busComparee = (BusImpl) comparee;
return nullableDeepEquals(this.model, busComparee.model)
&& nullableDeepEquals(this.state, busComparee.state)
&& nullableEquals(this.plate, busComparee.plate);
}
@Override
public String toString() {
return super.toString() + " plate = " + plate
+ " state = {" + state + "} model = {" + model + "}";
}
}
| Java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.