Joins additional data provided in subclass/ interfaces with base definition

@param base base definition
@param add  additional definition
@return joined definition
767576
private static Map<RouteDefinition, Method> join(Map<RouteDefinition, Method> base, Map<RouteDefinition, Method> add) {

		for (RouteDefinition definition : base.keySet()) {
			Method method = base.get(definition);

			RouteDefinition additional = find(add, method);
			definition.join(additional);
		}

		return base;
	}
529469
public void addBaseClasses(Class<?>... baseClasses) {

    if (this.baseClassList == null) {
      this.baseClassList = new ArrayList<>();
    }
    this.baseClassList.addAll(Arrays.asList(baseClasses));
  }
885739
@Override
	public boolean addAll(Collection<? extends E> c) {
		if(c.isEmpty()) return false;
		combine();
		if(combined==null) {
			combined = new HashSet<>(c);
			return true;
		} else {
			return combined.addAll(c);
		}
	}
932363
void add(MutableBigInteger addend) {
        int x = intLen;
        int y = addend.intLen;
        int resultLen = (intLen > addend.intLen ? intLen : addend.intLen);
        int[] result = (value.length < resultLen ? new int[resultLen] : value);

        int rstart = result.length-1;
        long sum;
        long carry = 0;

        // Add common parts of both numbers
        while(x > 0 && y > 0) {
            x--; y--;
            sum = (value[x+offset] & LONG_MASK) +
                (addend.value[y+addend.offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }

        // Add remainder of the longer number
        while(x > 0) {
            x--;
            if (carry == 0 && result == value && rstart == (x + offset))
                return;
            sum = (value[x+offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }
        while(y > 0) {
            y--;
            sum = (addend.value[y+addend.offset] & LONG_MASK) + carry;
            result[rstart--] = (int)sum;
            carry = sum >>> 32;
        }

        if (carry > 0) { // Result must grow in length
            resultLen++;
            if (result.length < resultLen) {
                int temp[] = new int[resultLen];
                // Result one word longer from carry-out; copy low-order
                // bits into new result.
                System.arraycopy(result, 0, temp, 1, result.length);
                temp[0] = 1;
                result = temp;
            } else {
                result[rstart--] = 1;
            }
        }

        value = result;
        intLen = resultLen;
        offset = result.length - resultLen;
    }
533710
public static <SOURCE, TARGET> Add<SOURCE, TARGET> to(Position.Readable<TARGET> targetPosition,
        Position.Readable<SOURCE> sourcePosition) {
        return new Add<>(sourcePosition, targetPosition);
    }
956664
void addDisjoint(MutableBigInteger addend, int n) {
        if (addend.isZero())
            return;

        int x = intLen;
        int y = addend.intLen + n;
        int resultLen = (intLen > y ? intLen : y);
        int[] result;
        if (value.length < resultLen)
            result = new int[resultLen];
        else {
            result = value;
            Arrays.fill(value, offset+intLen, value.length, 0);
        }

        int rstart = result.length-1;

        // copy from this if needed
        System.arraycopy(value, offset, result, rstart+1-x, x);
        y -= x;
        rstart -= x;

        int len = Math.min(y, addend.value.length-addend.offset);
        System.arraycopy(addend.value, addend.offset, result, rstart+1-y, len);

        // zero the gap
        for (int i=rstart+1-y+len; i < rstart+1; i++)
            result[i] = 0;

        value = result;
        intLen = resultLen;
        offset = result.length - resultLen;
    }
884110
public static ExtensionComponentSet union(final Collection<? extends ExtensionComponentSet> base) {
        return new ExtensionComponentSet() {
            @Override
            public <T> Collection<ExtensionComponent<T>> find(Class<T> type) {
                List<ExtensionComponent<T>> r = Lists.newArrayList();
                for (ExtensionComponentSet d : base)
                    r.addAll(d.find(type));
                return r;
            }
        };
    }
178345
private static void addBasePropertyDefinitions(AbstractTypeDefinition type) {

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.BASE_TYPE_ID,
                "Base Type Id",
                "Base Type Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.OBJECT_ID,
                "Object Id",
                "Object Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.OBJECT_TYPE_ID,
                "Type Id",
                "Type Id",
                PropertyType.ID,
                Cardinality.SINGLE,
                Updatability.ONCREATE,
                false,
                true));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.NAME,
                "Name",
                "Name",
                PropertyType.STRING,
                Cardinality.SINGLE,
                Updatability.READWRITE,
                false,
                true));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.CREATED_BY,
                    "Created By",
                    "Created By",
                    PropertyType.STRING,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.CREATION_DATE,
                    "Creation Date",
                    "Creation Date",
                    PropertyType.DATETIME,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.LAST_MODIFIED_BY,
                    "Last Modified By",
                    "Last Modified By",
                    PropertyType.STRING,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            queryableAndOrderable(
                createPropDef(
                    PropertyIds.LAST_MODIFICATION_DATE,
                    "Last Modification Date",
                    "Last Modification Date",
                    PropertyType.DATETIME,
                    Cardinality.SINGLE,
                    Updatability.READONLY,
                    false,
                    false)));

        type.addPropertyDefinition(
            createPropDef(
                PropertyIds.CHANGE_TOKEN,
                "Change Token",
                "Change Token",
                PropertyType.STRING,
                Cardinality.SINGLE,
                Updatability.READONLY,
                false,
                false));

    }
763085
protected void appendTableWithJoins(TableAlias alias, StringBuffer where, StringBuffer buf)
    {
        int stmtFromPos = 0;
        byte joinSyntax = getJoinSyntaxType();

        if (joinSyntax == SQL92_JOIN_SYNTAX)
        {
            stmtFromPos = buf.length(); // store position of join (by: Terry Dexter)
        }

        if (alias == getRoot())
        {
            // BRJ: also add indirection table to FROM-clause for MtoNQuery 
            if (getQuery() instanceof MtoNQuery)
            {
                MtoNQuery mnQuery = (MtoNQuery)m_query; 
                buf.append(getTableAliasForPath(mnQuery.getIndirectionTable(), null).getTableAndAlias());
                buf.append(", ");
            }           
            buf.append(alias.getTableAndAlias());
        }
        else if (joinSyntax != SQL92_NOPAREN_JOIN_SYNTAX)
        {
            buf.append(alias.getTableAndAlias());
        }

        if (!alias.hasJoins())
        {
            return;
        }

        for (Iterator it = alias.iterateJoins(); it.hasNext();)
        {
            Join join = (Join) it.next();

            if (joinSyntax == SQL92_JOIN_SYNTAX)
            {
                appendJoinSQL92(join, where, buf);
                if (it.hasNext())
                {
                    buf.insert(stmtFromPos, "(");
                    buf.append(")");
                }
            }
            else if (joinSyntax == SQL92_NOPAREN_JOIN_SYNTAX)
            {
                appendJoinSQL92NoParen(join, where, buf);
            }
            else
            {
                appendJoin(where, buf, join);
            }

        }
    }
1311971
public static <T> AppendingFactoryExpression<T> appending(Expression<T> base, Expression<?>... rest) {
        return new AppendingFactoryExpression<T>(base, rest);
    }
334778
public XNElement add(XNElement child) {
        child.parent = this;
        children.add(child);
        return child;
    }
401850
def add_bases(cls, *bases):
    
    assert inspect.isclass(cls), "Expected class object"
    for mixin in bases:
        assert inspect.isclass(mixin), "Expected class object for bases"
    new_bases = (bases + cls.__bases__)
    cls.__bases__ = new_bases
674967
public void addJoinColumns(String joinColumn)
    {
        if (joinColumns == null || joinColumns.isEmpty())
        {
            joinColumns = new HashSet<String>();
        }
        joinColumns.add(joinColumn);
    }
1279106
@Override
    public void add(Statement st, Resource... contexts) throws RepositoryException {
        add(st.getSubject(), st.getPredicate(), st.getObject(), mergeResource(st.getContext(), contexts));
    }
1157346
@Override
    public <T extends Event<?>> T add(T event, Channel... channels) {
        ((EventBase<?>) event).generatedBy(newEventsParent.get());
        ((EventBase<?>) event).processedBy(this);
        synchronized (queue) {
            queue.add(event, channels);
        }
        if (isRunning) {
            return event;
        }
        isRunning = true;
        GeneratorRegistry.instance().add(this);
        run();
        isRunning = false;
        return event;
    }
944530
public static void mergeTrackers(Map<Integer, Map<Integer, DRSiteDrIdTracker>> base,
                                     Map<Integer, Map<Integer, DRSiteDrIdTracker>> add)
    {
        for (Map.Entry<Integer, Map<Integer, DRSiteDrIdTracker>> clusterEntry : add.entrySet()) {
            final Map<Integer, DRSiteDrIdTracker> baseClusterEntry = base.get(clusterEntry.getKey());
            if (baseClusterEntry == null) {
                base.put(clusterEntry.getKey(), clusterEntry.getValue());
            } else {
                for (Map.Entry<Integer, DRSiteDrIdTracker> partitionEntry : clusterEntry.getValue().entrySet()) {
                    final DRConsumerDrIdTracker basePartitionTracker = baseClusterEntry.get(partitionEntry.getKey());
                    if (basePartitionTracker == null) {
                        baseClusterEntry.put(partitionEntry.getKey(), partitionEntry.getValue());
                    } else {
                        basePartitionTracker.mergeTracker(partitionEntry.getValue());
                    }
                }
            }
        }
    }
816840
@Override
    public void addCodeBase(ICodeBase codeBase) {
        if (codeBase.isApplicationCodeBase()) {
            if (!(codeBase instanceof IScannableCodeBase)) {
                throw new IllegalStateException();
            }
            appCodeBaseList.add((IScannableCodeBase) codeBase);
        } else {
            auxCodeBaseList.add(codeBase);
        }
    }