Creates a copy of this metadata object.  Modifications to this object don't affect the copy, and vice versa.
@return A copy of this metadata object.
965181
public BinaryOWLMetadata createCopy() {
        BinaryOWLMetadata copy = new BinaryOWLMetadata();
        copy.stringAttributes.putAll(stringAttributes);
        copy.intAttributes.putAll(intAttributes);
        copy.longAttributes.putAll(longAttributes);
        copy.doubleAttributes.putAll(doubleAttributes);
        copy.booleanAttributes.putAll(booleanAttributes);
        copy.byteArrayAttributes.putAll(byteArrayAttributes);
        for(String key : owlObjectAttributes.keySet()) {
            List<OWLObject> objectList = new ArrayList<OWLObject>(owlObjectAttributes.get(key));
            copy.owlObjectAttributes.put(key, objectList);
        }
        return copy;
    }
776227
public Datastream copy() {
        Datastream copy = new Datastream(id)
                .state(state)
                .controlGroup(controlGroup)
                .versionable(versionable);
        for (DatastreamVersion version: versions) {
            copy.versions().add(version.copy());
        }
        return copy;
    }
479852
public ExampleSet copy() {
        ExampleSet copy = new VectorSet();
        for (int i = 0; i < size(); i++)
            copy.add(x(i), y(i), id(i));

        return copy;
    }
462211
public Polygon copy() {
		float[] copyPoints = new float[points.length];
		System.arraycopy(points, 0, copyPoints, 0, copyPoints.length);
		
		return new Polygon(copyPoints);
	}
359371
def copy(self):
        
        copied = TransformForest()
        copied.base_frame = copy.deepcopy(self.base_frame)
        copied.transforms = copy.deepcopy(self.transforms)

        return copied
963433
public Table cloneTable()
    {
        Table ret = null;
        try {
            ret = (Table) super.clone();
        } catch (final CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return ret;
    }
556157
public CmsSitemapClipboardData copy() {

        LinkedHashMap<CmsUUID, CmsClientSitemapEntry> deletions = new LinkedHashMap<CmsUUID, CmsClientSitemapEntry>();
        deletions.putAll(m_deletions);
        LinkedHashMap<CmsUUID, CmsClientSitemapEntry> modifications = new LinkedHashMap<CmsUUID, CmsClientSitemapEntry>();
        modifications.putAll(m_modifications);
        return new CmsSitemapClipboardData(deletions, modifications);
    }
1328891
public Version<Attributes<T>> getOrCreateVersion()
   {
      List<Node> nodeList = childNode.get("version");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new VersionImpl<Attributes<T>>(this, "version", childNode, nodeList.get(0));
      }
      return createVersion();
   }
74812
public Translator<T> copy() {
        Translator<T> trans = new Translator<T>();

        if( isBundleBased() ) {
            for( Translation<T> t : values() ) {
                Locale loc = t.getLocale();
                
                trans.store(loc, t.getData());
            }
        }
        else {
            for( String lang : translations.keySet() ) {
                Map<String,Translation<T>> map = translations.get(lang);
                
                for( String ctry : map.keySet() ) {
                    trans.store(lang, ctry, map.get(ctry));
                }
            }
        }
        return trans;
    }
296910
public ServerConfiguration copy() throws IOException {
        ReadableByteArrayOutputStream out = new ReadableByteArrayOutputStream();
        serialize(out);
        return new ServerConfigurationParser(out.toInputStream()).parse();
    }
86898
public ConnectionParams copy() {
        ConnectionParams copy = new ConnectionParams(host, username, password, schema);
        return copy;
    }
518783
def copy(self):
        '''
         
        '''
        try:
            tmp = self.__class__()
        except Exception:
            tmp = self.__class__(self._pdict)
            
        tmp._serializers = self._serializers
        tmp.__deserializers = self.__deserializers

        return tmp
918484
public MapField<K, V> copy() {
        return new MapField<K, V>(converter, StorageMode.MAP, MapFieldLite.copy(getMap()), null);
    }
1066668
def copy(self):
        
        kb = KeyBundle()
        kb._keys = self._keys[:]

        kb.cache_time = self.cache_time
        kb.verify_ssl = self.verify_ssl
        if self.source:
            kb.source = self.source
            kb.fileformat = self.fileformat
            kb.keytype = self.keytype
            kb.keyusage = self.keyusage
            kb.remote = self.remote

        return kb
173401
public Table copy() {
        Table copy = new Table(name);
        for (Column<?> column : columnList) {
            copy.addColumns(column.emptyCopy(rowCount()));
        }

        int[] rows = new int[rowCount()];
        for (int i = 0; i < rowCount(); i++) {
            rows[i] = i;
        }
        Rows.copyRowsToTable(rows, this, copy);
        return copy;
    }
389300
@Override
	public AbstractMessage copy()
    {
        ObjectMessageImpl clone = new ObjectMessageImpl();
        copyCommonFields(clone);
        clone.body = this.body;
        
        return clone;
    }
199869
public DSLSentence copy() {
        final DSLSentence copy = new DSLSentence();

        copy.drl = getDrl();
        copy.definition = getDefinition();
        copy.values = mapCopy(getValues());

        return copy;
    }