Unlink (disassociate) the specified properties object.
        @param other: The object to unlink.
        @type other: L{Properties}
        @return: self
        @rtype: L{Properties}
424133
def unlink(self, other):
        
        p = other.__pts__
        return self.properties.unlink(p)
615432
def copy_from(self, other):
        
        # Need to copy all attributes, fields, relations
        self.__attributes__ = {k: v.copy() for k, v in other.__attributes__.items()}
        self.__fields__ = {k: v.copy() for k, v in other.__fields__.items()}
        self.__relations__ = {k: v.copy() for k, v in other.__relations__.items()}
        self.maps = {k: m.copy() for k, m in other.maps.items()}
        self.dimensions = other.dimensions.copy()
1276883
public void unlink(Object source, CollectionDescriptor cds, Object referenceToUnlink)
    {
        if(cds.isMtoNRelation())
        {
            m_broker.deleteMtoNImplementor(new MtoNImplementor(cds, source, referenceToUnlink));
        }
        else
        {
            ClassDescriptor cld = m_broker.getClassDescriptor(referenceToUnlink.getClass());
            m_broker.unlinkFK(referenceToUnlink, cld, cds);
        }
    }
115965
def remove(self, dic):
        '''
        '''
        for kw in dic:
            removePair = Pair(kw, dic[kw])
            self._remove([removePair])
815327
def merge(self, other):
        
        other = self.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge set with %s" % (str(other)))
        else:
            # self may be a subset of other 
            # or other may be a subset of self
            # merge mutual information
            if self.values:
                self.values = self.values.union(other.values)
            else:
                self.values = other.values.copy()
        return self
895611
def update(self, other, **kwargs):
        
        if other is None: return

        if not isinstance(other, dict):
            other = other.to_dict()
        self.__dict__.update(other, **kwargs)
243291
def unset(self, name):
        
        try:
            attr = self.getAttribute(name)
            self.attributes.remove(attr)
        except Exception:
            pass
        return self
217207
def close(self):
        
        try:
            if not self._closed and not self._owned:
                self._dispose()
        finally:
            self.detach()
979564
def removeProperty(self, login, property):
    
    self.send_removeProperty(login, property)
    self.recv_removeProperty()
545172
public Characters remove(Characters other) {
        checkArgNotNull(other, "other");
        if (!subtractive && !other.subtractive) {
            return removeFromChars(other.chars);
        }
        if (subtractive && other.subtractive) {
            return new Characters(false, other.removeFromChars(chars).chars);
        }
        return subtractive ? addToChars(other.chars) : retainAllChars(other.chars);
    }
780428
public void copyFromPropertyDescriptor(EntityField other) {
        this.setter = other.setter;
        this.getter = other.getter;
        this.javaType = other.javaType;
        this.name = other.name;
    }
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
603833
def unlink(self):
        
        hotel_room_reserv_line_obj = self.env['hotel.room.reservation.line']
        for reserv_rec in self:
            for rec in reserv_rec.reserve:
                hres_arg = [('room_id', '=', rec.id),
                            ('reservation_id', '=', reserv_rec.line_id.id)]
                myobj = hotel_room_reserv_line_obj.search(hres_arg)
                if myobj.ids:
                    rec.write({'isroom': True, 'status': 'available'})
                    myobj.unlink()
        return super(HotelReservationLine, self).unlink()
60800
public void remove(BitSet other)
    {
        int idx = Math.min(wlen, other.wlen);
        long [] thisArr = this.bits;
        long [] otherArr = other.bits;
        while (--idx >= 0)
        {
            thisArr[idx] &= ~otherArr[idx];
        }
    }
784282
def merge(self, other):
        
        other = BoolCell.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.value = other.value
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge T and F")
        else:
            raise Exception
        return self
494024
public void becomeCloneOf(ManagedObject other)
    {
        Anchor o = (Anchor)other;
        _rootStreamToken = o._rootStreamToken;
        _uniqueKeyTableToken = o._uniqueKeyTableToken;
    }
322204
def unlink(self):
        """"""
        if os.name == "posix":
            self.__linux_unlink__()
        elif os.name == "nt":
            self.__windows_unlink__()
        else:
            raise HolodeckException("Currently unsupported os: " + os.name)