The VSLC can either be added to a genotype or to a GVC.
        The vslc is added as a part of the parent.
        :param vslc_id:
        :param parent_id:
        :return:
199261
def addVSLCtoParent(self, vslc_id, parent_id):
        

        self.addParts(vslc_id, parent_id, self.globaltt['has_variant_part'])

        return
1172268
def add_parent(sender, instance, **kwargs):
    
    if not kwargs['created']:
        return
    for att in ['task', 'context']:
        parent = getattr(instance, att).item_id
        child = instance.item_id
        ItemRelation.objects.get_or_create(
            parent_id=parent,
            child_id=child,
            visible=True,
        )
474995
def parent(self, parent_object, limit_parent_language=True):
        
        return self.all().parent(parent_object, limit_parent_language)
580048
private void createVNodes(VCompound parent,List<Glyph> glyphs)
    {
        for(Glyph glyph: glyphs )
        {
            if (!glyphClazzOneOf(glyph, GlyphClazz.UNIT_OF_INFORMATION, GlyphClazz.STATE_VARIABLE))
            {
//                if(glyph.getClazz().equals(GlyphClazz.PROCESS.getClazz()))
//                {
//                    VCompound v = new VCompound(glyph); //TODO: v is never used; wat's the idea?
//                }

                if(!isChildless(glyph))
                {
                    VCompound v = new VCompound(glyph);
                    idToGLyph.put(glyph.getId(), glyph);
                    glyphToVNode.put(glyph, v);
                    parent.children.add(v);
                    createVNodes(v, glyph.getGlyph());
                }
                else
                {
                    VNode v = new VNode(glyph);
                    idToGLyph.put(glyph.getId(), glyph);
                    glyphToVNode.put(glyph, v);
                    parent.children.add(v);
                }
            }
        }
    }
227553
def ensure_parent_id(self):
        
        if self.trace_parent.span_id == self.id:
            self.trace_parent.span_id = "%016x" % random.getrandbits(64)
            logger.debug("Set parent id to generated %s", self.trace_parent.span_id)
        return self.trace_parent.span_id
381028
void addParentBuffer(StreamCharBuffer parent) {
        if (!notifyParentBuffersEnabled) return;

        if (parentBuffers==null) {
            parentBuffers=new HashSet<SoftReference<StreamCharBufferKey>>();
        }
        parentBuffers.add(new SoftReference<StreamCharBufferKey>(parent.bufferKey));
    }
934915
public void addVis(Object parent, VisualizationItem vis) {
    vistree.add(parent, vis);
    notifyFactories(vis);
    visChanged(vis);
  }
340788
def ensure_parent (self, mode=0o777, parents=False):
        
        return self.parent.ensure_dir (mode, parents)
585698
def add_parent(self,node):
    
    if not isinstance(node, (CondorDAGNode,CondorDAGManNode) ):
      raise CondorDAGNodeError, "Parent must be a CondorDAGNode or a CondorDAGManNode"
    self.__parents.append( node )
749900
public function addParent($term_id, $parent_id)
    {
        $this->testCanAddParents($term_id, 1);

        $this->termHierarchyRepository->addParent($term_id, $parent_id);
    }
894460
def _linkToParent(self, feature, parentName):
        
        parentParts = self.byFeatureName.get(parentName)
        if parentParts is None:
            raise GFF3Exception(
                "Parent feature does not exist: {}".format(parentName),
                self.fileName)
        # parent maybe disjoint
        for parentPart in parentParts:
            feature.parents.add(parentPart)
            parentPart.children.add(feature)
801386
def pbt_top_parent
      record = self
      return nil unless record.pbt_parent
      no_repeat = PolyBelongsTo::SingletonSet.new
      while !no_repeat.include?(record.pbt_parent) && !record.pbt_parent.nil?
        no_repeat.add?(record)
        record = record.pbt_parent
      end
      record
    end
1133114
def addParent(self, parent_id):
        

        if isinstance(parent_id, bool):
            raise exception.BadValue("Please input a valid workitem id")
        if isinstance(parent_id, six.string_types):
            parent_id = int(parent_id)
        if not isinstance(parent_id, int):
            raise exception.BadValue("Please input a valid workitem id")

        self.log.debug("Try to add a parent <Workitem %s> to current "
                       "<Workitem %s>",
                       parent_id,
                       self)

        headers = copy.deepcopy(self.rtc_obj.headers)
        headers["Content-Type"] = self.OSLC_CR_JSON
        req_url = "".join([self.url,
                           "?oslc_cm.properties=com.ibm.team.workitem.",
                           "linktype.parentworkitem.parent"])

        parent_tag = ("rtc_cm:com.ibm.team.workitem.linktype."
                      "parentworkitem.parent")
        parent_url = ("{0}/resource/itemName/com.ibm.team."
                      "workitem.WorkItem/{1}".format(self.rtc_obj.url,
                                                     parent_id))
        parent_original = {parent_tag: [{"rdf:resource": parent_url}]}

        self.put(req_url,
                 verify=False,
                 proxies=self.rtc_obj.proxies,
                 headers=headers,
                 data=json.dumps(parent_original))
        self.log.info("Successfully add a parent <Workitem %s> to current "
                      "<Workitem %s>",
                      parent_id,
                      self)
266672
def add_variant(self, chrom, pos, rs_id, ref, alt, qual, filt, info, form=None, genotypes=[]):
        
        variant_info = [chrom, pos, rs_id, ref, alt, qual, filt, info]
        if form:
            variant_info.append(form)
        for individual in genotypes:
            variant_info.append(individual)
        
        variant_line = '\t'.join(variant_info)
        variant = format_variant(
            line = variant_line, 
            header_parser = self.metadata, 
            check_info = self.check_info
        )
        
        if not (self.split_variants and len(variant['ALT'].split(',')) > 1):
            self.variants.append(variant)
            
        # If multiple alternative and split_variants we must split the variant                 
        else:
            for splitted_variant in split_variants(
                                                    variant_dict=variant, 
                                                    header_parser=self.metadata, 
                                                    allele_symbol=self.allele_symbol):
                self.variants.append(splitted_variant)
982629
def valid_parent_types(child)
      # could be a node object, or maybe a string
      str = child.respond_to?(:entity_type) ? child.entity_type : child
      self.up_taxonomy[str]
    end
481193
def bsp_father(node: tcod.bsp.BSP) -> Optional[tcod.bsp.BSP]:
    
    return node.parent
718883
def parent=(parent)
      if @rank.nil?
        raise Taxonifi::NameError, "Parent of name can not be set if rank of child is not set." 
      end

      # TODO: ICZN class over-ride
      if parent.class != Taxonifi::Model::Name
        raise NameError, "Parent is not a Taxonifi::Model::Name."
      end

      if (RANKS.index(parent.rank) >= RANKS.index(self.rank))
        #  warn "WARNING:: Assigning parent to Name at same or lower rank than self (#{rank})."
        raise NameError, "Parent is same or lower rank than self (#{rank})."
      end

      @parent = parent
    end