Join type, one of `miter`, `round`, `bevel`.
12597
def line_join_type(self):
        """"""
        key = self._data.get(b'strokeStyleLineJoinType').enum
        return self.STROKE_STYLE_LINE_JOIN_TYPES.get(key, str(key))
925186
function join(joiner, ...values) {
    if (values.length > 0) {
      return concat([],...values).join(joiner);
    }

    // Manually currying
    return (...values) => join(joiner, ...values);
  }
1011233
def get_joining_type_property(value, is_bytes=False):
    """"""

    obj = unidata.ascii_joining_type if is_bytes else unidata.unicode_joining_type

    if value.startswith('^'):
        negated = value[1:]
        value = '^' + unidata.unicode_alias['joiningtype'].get(negated, negated)
    else:
        value = unidata.unicode_alias['joiningtype'].get(value, value)

    return obj[value]
1342991
def _glob_pjoin(*parts):
    """"""
    if parts[0] in ('.', ''):
        parts = parts[1:]
    return pjoin(*parts).replace(os.sep, '/')
660976
function join(separator, itemList) {
    var result = "";
    for (var i = 0; i < itemList.length; i++) {
        if (i > 0) {
            result += separator;
        }
        result += itemList[i];
    }
    return result;
}
703299
def _join(segments):
    """"""
    new = []
    start = segments[0][0]
    end = segments[0][1]
    for i in range(len(segments)-1):
        if segments[i+1][0] != segments[i][1]:
            new.append((start, end))
            start = segments[i+1][0]
        end = segments[i+1][1]
    new.append((start, end))
    return new
514964
public static String join(String joiner, String... parts) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < parts.length; i++) {
            builder.append(parts[i]);
            if (i < parts.length - 1) {
                builder.append(joiner);
            }
        }
        return builder.toString();
    }
195984
def p_UnionType(p):
  
  t = [p[2]] + [p[4]] + p[5]
  p[0] = model.UnionType(t=t)
652479
public function join($join = null, $on = [], $type = 'LEFT')
    {
        if (!$join) {
            return $this;
        }
        $this->_parts['joins'][] = compact('join', 'on', 'type');
        return $this;
    }
169963
function endPolygon(coordCurr, normPrev, normNext, join_type, v, context) {
    // If polygon ends on a tile boundary, don't add a join
    if (isCoordOutsideTile(coordCurr)) {
        addVertex(coordCurr, normPrev, normPrev, 1, v, context, 1);
        addVertex(coordCurr, normPrev, normPrev, 0, v, context, -1);
        indexPairs(1, context);
    }
    else {
        // If polygon ends within a tile, add Miter or no joint (join added on startPolygon)
        var miterVec = createMiterVec(normPrev, normNext);

        if (join_type === JOIN_TYPE.miter && Vector.lengthSq(miterVec) > context.miter_len_sq) {
            join_type = JOIN_TYPE.bevel; // switch to bevel
        }

        if (join_type === JOIN_TYPE.miter) {
            addVertex(coordCurr, miterVec, normPrev, 1, v, context, 1);
            addVertex(coordCurr, miterVec, normPrev, 0, v, context, -1);
            indexPairs(1, context);
        }
        else {
            addVertex(coordCurr, normPrev, normPrev, 1, v, context, 1);
            addVertex(coordCurr, normPrev, normPrev, 0, v, context, -1);
            indexPairs(1, context);
        }
    }
}
1127041
def spatial_join(other, buffer = 0, table_alias = 'features', other_alias = 'other_features', geom = 'geom_lowres')
      scope = features_scope(self).select("#{geom} AS geom").select(:spatial_model_id)

      other_scope = features_scope(other)
      other_scope = other_scope.select("ST_Union(#{geom}) AS geom").select("ST_Buffer(ST_Union(#{geom}), #{buffer.to_i}) AS buffered_geom")

      return joins(%Q(INNER JOIN (#{scope.to_sql}) AS #{table_alias} ON #{table_alias}.spatial_model_id = #{table_name}.id))
            .joins(%Q(INNER JOIN (#{other_scope.to_sql}) AS #{other_alias} ON ST_Intersects(#{table_alias}.geom, #{other_alias}.buffered_geom)))
    end
84548
public static int sld2awtJoin( String sldJoin ) {
        if (sldJoin.equals(lineJoinNames[1])) {
            return BasicStroke.JOIN_BEVEL;
        } else if (sldJoin.equals("") || sldJoin.equals(lineJoinNames[2])) {
            return BasicStroke.JOIN_MITER;
        } else if (sldJoin.equals(lineJoinNames[3])) {
            return BasicStroke.JOIN_ROUND;
        } else {
            throw new IllegalArgumentException("unsupported line join");
        }
    }
1057879
function(context, geometry, style, featureId, type) {
        var components = geometry.components;
        var len = components.length;
        context.beginPath();
        var start = this.getLocalXY(components[0]);
        var x = start[0];
        var y = start[1];
        if (!isNaN(x) && !isNaN(y)) {
            context.moveTo(start[0], start[1]);
            for (var i=1; i<len; ++i) {
                var pt = this.getLocalXY(components[i]);
                context.lineTo(pt[0], pt[1]);
            }
            if (type === "fill") {
                context.fill();
            } else {
                context.stroke();
            }
        }
    }
1313716
public static FlinkJoinType toFlinkJoinType(JoinRelType joinRelType) {
		switch (joinRelType) {
			case INNER:
				return FlinkJoinType.INNER;
			case LEFT:
				return FlinkJoinType.LEFT;
			case RIGHT:
				return FlinkJoinType.RIGHT;
			case FULL:
				return FlinkJoinType.FULL;
			default:
				throw new IllegalArgumentException("invalid: " + joinRelType);
		}
	}
1068202
function join (table, args, type) {
    this.typecheck && t.typecheck('join', [table, args, type]);
    if ('string'===typeof args) args = [args];
    var result = ['join',table,'on',args.join(' and ')];
    if (type) result.splice(0,0,type);
    return result.join(' ');
}
1034932
function addJoin(join_type, v, coordCurr, normPrev, normNext, isBeginning, context) {
    var miterVec = createMiterVec(normPrev, normNext);
    var isClockwise = (normNext[0] * normPrev[1] - normNext[1] * normPrev[0] > 0);

    if (context.texcoord_index != null) {
        zero_v[1] = v;
        one_v[1] = v;
    }

    if (isClockwise){
        addVertex(coordCurr, miterVec, miterVec, 1, v, context, 1);
        addVertex(coordCurr, normPrev, miterVec, 0, v, context, -1);

        if (!isBeginning) {
            indexPairs(1, context);
        }

        addFan(coordCurr,
            // extrusion vector of first vertex
            Vector.neg(normPrev),
            // controls extrude distance of pivot vertex
            miterVec,
            // extrusion vector of last vertex
            Vector.neg(normNext),
            // line normal (unused here)
            miterVec,
            // uv coordinates
            zero_v, one_v, zero_v,
            false, (join_type === JOIN_TYPE.bevel), context
        );

        addVertex(coordCurr, miterVec, miterVec, 1, v, context, 1);
        addVertex(coordCurr, normNext, miterVec, 0, v, context, -1);
    } else {
        addVertex(coordCurr, normPrev, miterVec, 1, v, context, 1);
        addVertex(coordCurr, miterVec, miterVec, 0, v, context, -1);

        if (!isBeginning) {
            indexPairs(1, context);
        }

        addFan(coordCurr,
            // extrusion vector of first vertex
            normPrev,
            // extrusion vector of pivot vertex
            Vector.neg(miterVec),
            // extrusion vector of last vertex
            normNext,
            // line normal for offset
            miterVec,
            // uv coordinates
            one_v, zero_v, one_v,
            false, (join_type === JOIN_TYPE.bevel), context
        );

        addVertex(coordCurr, normNext, miterVec, 1, v, context, 1);
        addVertex(coordCurr, miterVec, miterVec, 0, v, context, -1);
    }
}
421109
def merge(left, right, how='inner', key=None, left_key=None, right_key=None,
          left_as='left', right_as='right'):
    
    return join(left, right, how, key, left_key, right_key,
                join_fn=make_union_join(left_as, right_as))