Override of {@link BaseRelation#overrides}.

@method
@protected
@see {@link BaseRelation#overrides}
977543
function() {
    this._super();

    if (!this._options.implicit) {
      this.overrideProperty('<singular>', 'item', 'set');
      this.addHelper('get<Singular>', 'item');
      this.addHelper('set<Singular>', 'set');
      this.addHelper('create<Singular>', 'create');
      this.addHelper('fetch<Singular>', 'fetch');

      this.addOverride('<foreignKey>', _.extend(function(/*relationKey*/) {
        return attr(undefined, { writable: false });
      }, { optional: true }));

      this.overrideMethod('init', 'initialize');
      this.overrideMethod('_dependents', 'dependents');
      this.overrideMethod('_reliants', 'reliants');
      this.overrideMethod('_presave', 'presave');
      this.overrideMethod('_postsave', 'postsave');
    }
  }
1074778
public void setRelation_ref(Relation v) {
    if (RelationMention_Type.featOkTst && ((RelationMention_Type)jcasType).casFeat_relation_ref == null)
      jcasType.jcas.throwFeatMissing("relation_ref", "de.julielab.jules.types.ace.RelationMention");
    jcasType.ll_cas.ll_setRefValue(addr, ((RelationMention_Type)jcasType).casFeatCode_relation_ref, jcasType.ll_cas.ll_getFSRef(v));}
826947
public void setRelatedFindingsProductArn(java.util.Collection<StringFilter> relatedFindingsProductArn) {
        if (relatedFindingsProductArn == null) {
            this.relatedFindingsProductArn = null;
            return;
        }

        this.relatedFindingsProductArn = new java.util.ArrayList<StringFilter>(relatedFindingsProductArn);
    }
879628
public void addRelation(String property, Relation relation)
    {
        relationsMap.put(property, relation);
        addRelationName(relation);
    }
1065923
@Override
  public void applySubclassRelationship(
      final NominalTypeBuilder parent, final NominalTypeBuilder child, SubclassType type) {
    super.applySubclassRelationship(parent, child, type);
    if (type == SubclassType.INHERITS) {
      final FunctionType childCtor = child.constructor();
      child.declareConstructorProperty(
          "superClass_", parent.prototypeOrInstance(), childCtor.getSource());
      // Notice that constructor functions do not need to be covariant on the superclass.
      // So if G extends F, new G() and new F() can accept completely different argument
      // types, but G.prototype.constructor needs to be covariant on F.prototype.constructor.
      // To get around this, we just turn off type-checking on arguments and return types
      // of G.prototype.constructor.
      FunctionType qmarkCtor = childCtor.forgetParameterAndReturnTypes();
      child.declarePrototypeProperty("constructor", qmarkCtor, childCtor.getSource());
    }
  }
922031
private <T extends Property> Map<String, String> getOverriddenImplementationConfiguration(
            Collection<T> overridableProperties) {

        Map<String, String> ret = new HashMap<>();

        overridableProperties.forEach(p -> {
            String val = getProperty(p, null);
            if (val != null) {
                ret.put(p.getPropertyName(), val);
            }
        });

        implementationConfiguration.forEach(ret::putIfAbsent);

        return ret;
    }
1211627
public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
      Node node = nl.item(i);
      if (node instanceof Element && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
        Element ele = (Element) node;
        String methodName = ele.getAttribute(NAME_ATTRIBUTE);
        String beanRef = ele.getAttribute(BEAN_ELEMENT);
        LookupOverride override = new LookupOverride(methodName, beanRef);
        override.setSource(extractSource(ele));
        overrides.addOverride(override);
      }
    }
  }
54769
private function initRelations() {
    if ($this->relations == null) {
      $this->relations = [];
      $this->relations['byrole'] = [];
      $this->relations['bytype'] = [];

      $relations = $this->getRelations();
      foreach ($relations as $relation) {
        $this->relations['byrole'][$relation->getOtherRole()] = $relation;
        $otherType = $relation->getOtherType();
        if (!isset($this->relations['bytype'][$otherType])) {
          $this->relations['bytype'][$otherType] = [];
        }
        $this->relations['bytype'][$otherType][] = $relation;
        $this->relations['bytype'][$this->persistenceFacade->getSimpleType($otherType)][] = $relation;
      }
    }
  }
155855
public void overrideCubeProperties(DockerCompositions overrideDockerCompositions) {
        final Set<String> containerIds = overrideDockerCompositions.getContainerIds();
        for (String containerId : containerIds) {

            // main definition of containers contains a container that must be overrode
            if (containers.containsKey(containerId)) {
                final CubeContainer cubeContainer = containers.get(containerId);
                final CubeContainer overrideCubeContainer = overrideDockerCompositions.get(containerId);

                cubeContainer.setRemoveVolumes(overrideCubeContainer.getRemoveVolumes());
                
                cubeContainer.setAlwaysPull(overrideCubeContainer.getAlwaysPull());

                if (overrideCubeContainer.hasAwait()) {
                    cubeContainer.setAwait(overrideCubeContainer.getAwait());
                }

                if (overrideCubeContainer.hasBeforeStop()) {
                    cubeContainer.setBeforeStop(overrideCubeContainer.getBeforeStop());
                }

                if (overrideCubeContainer.isManual()) {
                    cubeContainer.setManual(overrideCubeContainer.isManual());
                }

                if (overrideCubeContainer.isKillContainer()) {
                    cubeContainer.setKillContainer(overrideCubeContainer.isKillContainer());
                }
            } else {
                logger.warning(String.format("Overriding Container %s are not defined in main definition of containers.",
                    containerId));
            }
        }
    }
592457
public List<ExtendedRelation> getBaseTableRelations(String baseTable)
			throws SQLException {
		return queryForEq(ExtendedRelation.COLUMN_BASE_TABLE_NAME, baseTable);
	}
580804
public void setRelationalDatabases(java.util.Collection<RelationalDatabase> relationalDatabases) {
        if (relationalDatabases == null) {
            this.relationalDatabases = null;
            return;
        }

        this.relationalDatabases = new java.util.ArrayList<RelationalDatabase>(relationalDatabases);
    }
1075303
private void modifyEndNodes(final Principal user, final NodeInterface startNode, final NodeInterface endNode, final RelationshipInterface rel, final boolean isDeletion) {

		// only modify if nodes are accessible
		if (startNode != null && endNode != null) {

			final RelationshipType relType = rel.getRelType();

			if (RelType.OWNS.equals(relType)) {

				modifyOwner(startNode);
				modifyOwner(endNode);
				return;
			}

			if (RelType.SECURITY.equals(relType)) {

				modifySecurity(startNode);
				modifySecurity(endNode);
				return;
			}

			if (RelType.IS_AT.equals(relType)) {

				modifyLocation(startNode);
				modifyLocation(endNode);
				return;
			}

			final Relation relation  = Relation.getInstance((Class)rel.getClass());
			final PropertyKey source = relation.getSourceProperty();
			final PropertyKey target = relation.getTargetProperty();
			final Object sourceValue = source != null && source.isCollection() ? new LinkedList<>() : null;
			final Object targetValue = target != null && target.isCollection() ? new LinkedList<>() : null;

			modify(user, startNode, target, null, targetValue);
			modify(user, endNode, source, null, sourceValue);

			if (source != null && target != null) {

				if (isDeletion) {

					// update removed properties
					getState(startNode).remove(target, endNode);
					getState(endNode).remove(source, startNode);

				} else {


					// update added properties
					getState(startNode).add(target, endNode);
					getState(endNode).add(source, startNode);
				}

			} else {

				// dont log so much..
				//logger.warn("No properties registered for {}: source: {}, target: {}", rel.getClass(), source, target);
			}
		}
	}
494963
public void removeRelationship(ExtendedRelation extendedRelation) {

		try {
			if (extendedRelationsDao.isTableExists()) {
				geoPackage.deleteTable(extendedRelation.getMappingTableName());
				extendedRelationsDao.delete(extendedRelation);
			}
		} catch (SQLException e) {
			throw new GeoPackageException("Failed to remove relationship '"
					+ extendedRelation.getRelationName() + "' between "
					+ extendedRelation.getBaseTableName() + " and "
					+ extendedRelation.getRelatedTableName()
					+ " with mapping table "
					+ extendedRelation.getMappingTableName(), e);
		}
	}
189629
private void overrideAbstractMethods() throws IOException
    {
        for (final ExecutableElement method : El.getEffectiveMethods(superClass))
        {
            if (method.getModifiers().contains(Modifier.ABSTRACT))
            {
                if (
                        method.getAnnotation(Terminal.class) != null || 
                        method.getAnnotation(Rule.class) != null || 
                        method.getAnnotation(Rules.class) != null )
                {
                    implementedAbstractMethods.add(method);
                    MethodCompiler mc = new MethodCompiler()
                    {
                        @Override
                        protected void implement() throws IOException
                        {
                            TypeMirror returnType = method.getReturnType();
                            List<? extends VariableElement> params = method.getParameters();
                            if (returnType.getKind() != TypeKind.VOID && params.size() == 1)
                            {
                                nameArgument(ARG, 1);
                                try
                                {
                                    convert(ARG, returnType);
                                }
                                catch (IllegalConversionException ex)
                                {
                                    throw new IOException("bad conversion with "+method, ex);
                                }
                                treturn();
                            }
                            else
                            {
                                if (returnType.getKind() == TypeKind.VOID && params.size() == 0)
                                {
                                    treturn();
                                }
                                else
                                {
                                    throw new IllegalArgumentException("cannot implement abstract method "+method);
                                }
                            }
                        }
                    };
                    subClass.overrideMethod(mc, method, Modifier.PROTECTED);
                }
            }
        }
    }
1206970
private Properties loadOverrides(File baseDir, Properties properties) throws IOException {
        return loadProperties(baseDir, properties, "override", true);
    }
241698
function UMLUndirectedRelationship() {
        type.UndirectedRelationship.apply(this, arguments);

        /** @member {UMLStereotype} */
        this.stereotype = null;

        /** @member {string} */
        this.visibility = VK_PUBLIC;

        // mixin UMLElementMixin
        _.extend(UMLUndirectedRelationship.prototype, UMLElementMixin);
    }
529469
public void addBaseClasses(Class<?>... baseClasses) {

    if (this.baseClassList == null) {
      this.baseClassList = new ArrayList<>();
    }
    this.baseClassList.addAll(Arrays.asList(baseClasses));
  }