Return a replica of this instance with its quality value removed.
@return the same instance if the media type doesn't contain a quality value, or a new one otherwise
198655
public MediaType removeQualityValue() {
		if (!this.parameters.containsKey(PARAM_QUALITY_FACTOR)) {
			return this;
		}
		Map<String, String> params = new LinkedHashMap<String, String>(this.parameters);
		params.remove(PARAM_QUALITY_FACTOR);
		return new MediaType(this, params);
	}
518948
def clone(self, klass=None, memo=None, **kwargs):
        
        obj = Empty()
        obj.__class__ = klass or self.__class__

        obj.resource = self.resource

        obj.filters = self.filters.copy()
        obj.order_by = self.order_by

        obj.low_mark = self.low_mark
        obj.high_mark = self.high_mark

        obj.__dict__.update(kwargs)

        return obj
153592
public SampleTableBox getSampleTableBox() {
        if (sampleTableBox != null) {
            return sampleTableBox;
        }
        MediaBox mdia = getMediaBox();
        if (mdia != null) {
            MediaInformationBox minf = mdia.getMediaInformationBox();
            if (minf != null) {
                sampleTableBox = minf.getSampleTableBox();
                return sampleTableBox;
            }
        }
        return null;

    }
1323765
public RequestViewMetadata cloneInstance()
    {
        RequestViewMetadata rvm = new RequestViewMetadata();
        rvm.initialProcessedClasses = new HashMap<Class<?>, Boolean>(
                this.initialProcessedClasses != null ? 
                    this.initialProcessedClasses : this.processedClasses);
        if (this.initialAddedResources != null)
        {
            rvm.initialAddedResources = new HashMap<ResourceDependency, Boolean>(
                    this.initialAddedResources);
        }
        else if (this.addedResources != null)
        {
            rvm.initialAddedResources = new HashMap<ResourceDependency, Boolean>(
                    this.addedResources);
        }
        return rvm;
    }
148965
public SessionContext copy()
    {
        SessionContext copy = new SessionContext();
        copy.brownoutMode = brownoutMode;
        copy.cancelled = cancelled;
        copy.shouldStopFilterProcessing = shouldStopFilterProcessing;
        copy.shouldSendErrorResponse = shouldSendErrorResponse;
        copy.errorResponseSent = errorResponseSent;
        copy.debugRouting = debugRouting;
        copy.debugRequest = debugRequest;
        copy.debugRequestHeadersOnly = debugRequestHeadersOnly;
        copy.timings = timings;

        Iterator<String> it = keySet().iterator();
        String key = it.next();
        while (key != null) {
            Object orig = get(key);
            try {
                Object copyValue = DeepCopy.copy(orig);
                if (copyValue != null) {
                    copy.set(key, copyValue);
                } else {
                    copy.set(key, orig);
                }
            } catch (NotSerializableException e) {
                copy.set(key, orig);
            }
            if (it.hasNext()) {
                key = it.next();
            } else {
                key = null;
            }
        }
        return copy;
    }
677794
public CmsAliasTableRow copy() {

        CmsAliasTableRow result = new CmsAliasTableRow();
        result.setKey(m_key);
        result.setResourcePath(m_resourcePath);
        result.setStructureId(m_structureId);
        result.setChanged(m_isChanged);
        result.setMode(m_mode);
        result.setPathError(m_pathError);
        result.setAliasError(m_aliasError);
        result.setAliasPath(m_aliasPath);
        result.setEdited(m_isEdited);
        result.setOriginalStructureId(m_originalStructureId);

        return result;
    }
122302
def duplicate(self):
        '''
        
        '''
        return self.__class__(self.method, self.status, self.date, self.ref)
570083
public JsonLdOptions copy() {
        final JsonLdOptions copy = new JsonLdOptions(base);

        copy.setCompactArrays(compactArrays);
        copy.setExpandContext(expandContext);
        copy.setProcessingMode(processingMode);
        copy.setDocumentLoader(documentLoader);
        copy.setEmbed(embed);
        copy.setExplicit(explicit);
        copy.setOmitDefault(omitDefault);
        copy.setOmitGraph(omitGraph);
        copy.setFrameExpansion(frameExpansion);
        copy.setPruneBlankNodeIdentifiers(pruneBlankNodeIdentifiers);
        copy.setRequireAll(requireAll);
        copy.setAllowContainerSetOnType(allowContainerSetOnType);
        copy.setUseRdfType(useRdfType);
        copy.setUseNativeTypes(useNativeTypes);
        copy.setProduceGeneralizedRdf(produceGeneralizedRdf);
        copy.format = format;
        copy.useNamespaces = useNamespaces;
        copy.outputForm = outputForm;

        return copy;
    }
1000344
public BufferedImage getNewImageInstance() {
        BufferedImage buf = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());
        buf.setData(image.getData());
        return buf;
    }
1244558
def copy(self):
        
        out = type(self)(
            name=self.__name,
            field=self.__field,
            display=self.__display,
            flags=self.__flags,
            default=self.__default,
            defaultOrder=self.__defaultOrder,
            getter=self.__gettermethod,
            setter=self.__settermethod,
            queryFilter=self.__query_filter,
            shortcut=self.__shortcut,
            readPermit=self.__readPermit,
            writePermit=self.__writePermit,
            order=self.__order
        )

        return out
1320786
public EntityCacheStatistics copy() {
        final EntityCacheStatistics copy = new EntityCacheStatistics();
        copy.entities = entities;
        copy.hits = hits;
        copy.misses = misses;
        return copy;
    }
1186311
public T copy() {
        T copy = Instantiator.of(type).instantiate();
        return copyInto(copy);
    }
890629
public function withMediaByPublicId(): self
    {
        if (!$this->byGuid) {
            return $this;
        }

        $url = clone $this;
        $url->byGuid = false;

        return $url;
    }
645542
def copy(self):
        '''
        
        '''
        dup = super(Conditional, self).copy()
        condition = self._condition.copy()
        condition.invalidate(self)
        dup._condition = condition
        return dup
113360
public VideoData duplicate() throws IOException, ClassNotFoundException {
        VideoData result = new VideoData();
        // serialize
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        writeExternal(oos);
        oos.close();
        // convert to byte array
        byte[] buf = baos.toByteArray();
        baos.close();
        // create input streams
        ByteArrayInputStream bais = new ByteArrayInputStream(buf);
        ObjectInputStream ois = new ObjectInputStream(bais);
        // deserialize
        result.readExternal(ois);
        ois.close();
        bais.close();
        // clone the header if there is one
        if (header != null) {
            result.setHeader(header.clone());
        }
        result.setSourceType(sourceType);
        result.setSource(source);
        result.setTimestamp(timestamp);
        return result;
    }
86898
public ConnectionParams copy() {
        ConnectionParams copy = new ConnectionParams(host, username, password, schema);
        return copy;
    }
513399
protected Proxy copy(){
       Socks4Proxy copy = new Socks4Proxy(proxyIP,proxyPort,user);
       copy.directHosts = this.directHosts;
       copy.chainProxy = chainProxy;
       return copy;
    }