class ShortFieldImpl<ENTITY, D> implements ShortField<ENTITY, D> {
    
    private final ColumnIdentifier<ENTITY> identifier;
    private final GetShort<ENTITY, D> getter;
    private final ShortSetter<ENTITY> setter;
    private final TypeMapper<D, Short> typeMapper;
    private final boolean unique;
    private final String tableAlias;
    
    public ShortFieldImpl(
            ColumnIdentifier<ENTITY> identifier,
            ShortGetter<ENTITY> getter,
            ShortSetter<ENTITY> setter,
            TypeMapper<D, Short> typeMapper,
            boolean unique) {
        this.identifier = requireNonNull(identifier);
        this.getter     = new GetShortImpl<>(this, getter);
        this.setter     = requireNonNull(setter);
        this.typeMapper = requireNonNull(typeMapper);
        this.unique     = unique;
        this.tableAlias = identifier.getTableId();
    }
    
    private ShortFieldImpl(
            ColumnIdentifier<ENTITY> identifier,
            ShortGetter<ENTITY> getter,
            ShortSetter<ENTITY> setter,
            TypeMapper<D, Short> typeMapper,
            boolean unique,
            String tableAlias) {
        this.identifier = requireNonNull(identifier);
        this.getter     = new GetShortImpl<>(this, getter);
        this.setter     = requireNonNull(setter);
        this.typeMapper = requireNonNull(typeMapper);
        this.unique     = unique;
        this.tableAlias = requireNonNull(tableAlias);
    }
    
    @Override
    public ColumnIdentifier<ENTITY> identifier() {
        return identifier;
    }
    
    @Override
    public ShortSetter<ENTITY> setter() {
        return setter;
    }
    
    @Override
    public GetShort<ENTITY, D> getter() {
        return getter;
    }
    
    @Override
    public TypeMapper<D, Short> typeMapper() {
        return typeMapper;
    }
    
    @Override
    public boolean isUnique() {
        return unique;
    }
    
    @Override
    public String tableAlias() {
        return tableAlias;
    }
    
    @Override
    public ShortField<ENTITY, D> tableAlias(String tableAlias) {<FILL_FUNCTION_BODY>}
    
    @Override
    public ShortFieldComparator<ENTITY, D> comparator() {
        return new ShortFieldComparatorImpl<>(this);
    }
    
    @Override
    public ShortFieldComparator<ENTITY, D> reversed() {
        return comparator().reversed();
    }
    
    @Override
    public ShortFieldComparator<ENTITY, D> comparatorNullFieldsFirst() {
        return comparator();
    }
    
    @Override
    public NullOrder getNullOrder() {
        return NullOrder.LAST;
    }
    
    @Override
    public boolean isReversed() {
        return false;
    }
    
    @Override
    public FieldPredicate<ENTITY> equal(Short value) {
        return new ShortEqualPredicate<>(this, value);
    }
    
    @Override
    public FieldPredicate<ENTITY> greaterThan(Short value) {
        return new ShortGreaterThanPredicate<>(this, value);
    }
    
    @Override
    public FieldPredicate<ENTITY> greaterOrEqual(Short value) {
        return new ShortGreaterOrEqualPredicate<>(this, value);
    }
    
    @Override
    public FieldPredicate<ENTITY> between(
            Short start,
            Short end,
            Inclusion inclusion) {
        return new ShortBetweenPredicate<>(this, start, end, inclusion);
    }
    
    @Override
    public FieldPredicate<ENTITY> in(Collection<Short> values) {
        return new ShortInPredicate<>(this, collectionToSet(values));
    }
    
    @Override
    public SpeedmentPredicate<ENTITY> notEqual(Short value) {
        return new ShortNotEqualPredicate<>(this, value);
    }
    
    @Override
    public SpeedmentPredicate<ENTITY> lessOrEqual(Short value) {
        return new ShortLessOrEqualPredicate<>(this, value);
    }
    
    @Override
    public SpeedmentPredicate<ENTITY> lessThan(Short value) {
        return new ShortLessThanPredicate<>(this, value);
    }
    
    @Override
    public SpeedmentPredicate<ENTITY> notBetween(
            Short start,
            Short end,
            Inclusion inclusion) {
        return new ShortNotBetweenPredicate<>(this, start, end, inclusion);
    }
    
    @Override
    public SpeedmentPredicate<ENTITY> notIn(Collection<Short> values) {
        return new ShortNotInPredicate<>(this, collectionToSet(values));
    }
}

        requireNonNull(tableAlias);
        return new ShortFieldImpl<>(identifier, getter, setter, typeMapper, unique, tableAlias);
    
<no_super_class>