Creates a clone of this MatchTarget.  Override only if the system clone support does
not produce a correct result.
978326
public MatchTarget duplicate()
  {
    try
    {
      return (MatchTarget) clone();
    }
    catch (CloneNotSupportedException e)
    {
      // No FFDC Code Needed.
      // FFDC driven by wrapper class.
      FFDC.processException(cclass,
          "com.ibm.ws.sib.matchspace.MatchTarget.duplicate",
          e,
          "1:112:1.15");        
      // should not happen
      throw new IllegalStateException();
    }
  }
616533
def clone(self, name=None):
        
        ret = self.copy_template().insert_many(self.obs)(name)
        return ret
558856
function clone(target) {
  if (target == null || typeof target !== "object") return target;
  var cloned = target.constructor ? target.constructor() : Object.create(null);
  for (var attr in target) {
    if (target.hasOwnProperty(attr)) {
      cloned[attr] = target[attr];
    }
  }
  return cloned;
}
211980
def clone(self):
    """"""
    return type(self)(self.__cmp, self.__key, self.__reverse, name = self.name, dataFormat = self._dataFormat)
1187904
def clone(self):
    """"""
    return type(self)(name = self.name, dataFormat = self._dataFormat)
4912
def _clone(self, *args, **kwargs):
        
        for attr in ("_search_terms", "_search_fields", "_search_ordered"):
            kwargs[attr] = getattr(self, attr)
        return super(SearchableQuerySet, self)._clone(*args, **kwargs)
996294
@Override
    public RuleBasedCollator cloneAsThawed() {
        try {
            RuleBasedCollator result = (RuleBasedCollator) super.clone();
            // since all collation data in the RuleBasedCollator do not change
            // we can safely assign the result.fields to this collator 
            // except in cases where we can't
            result.settings = settings.clone();
            result.collationBuffer = null;
            result.frozenLock = null;
            return result;
        } catch (CloneNotSupportedException e) {
            // Clone is implemented
            return null;
        }
    }
305474
def clone(cls, variable, **kwargs):
        
        return cls(variable.name, lb=variable.lb, ub=variable.ub, type=variable.type, **kwargs)
69967
def clone(self, *args, **kwargs):
        
        return self._client.clone_scope(*args, source_scope=self, **kwargs)
403064
def create(self):
        
        session = client.get_client().create_session()

        if not self._base_query(session).count() > 0:
            # store a new target instance to the database
            marker = ORMTargetMarker(name=self.name,
                                     params=self.params)
            session.add(marker)
            session.commit()

        session.close()
395918
def clone_from(source)
      raise ContainerError, "Container already exists." if exists?

      unless LXC.container(source).exists?
        raise ContainerError, "Source container does not exist."
      end

      run("clone", "-o", source)
      exists?
    end
1356348
def _clone(self):
        
        clone = self.__class__(self._entity_cls, criteria=self._criteria,
                               offset=self._offset, limit=self._limit,
                               order_by=self._order_by)
        return clone
501300
<T> DomainObjectMatch<T> createMatchInternal(Class<T> domainObjectType) {
		DomainObjectMatch<T> ret =APIAccess.createDomainObjectMatch(domainObjectType,
				this.queryExecutor.getDomainObjectMatches().size(),
				this.queryExecutor.getMappingInfo());
		this.queryExecutor.getDomainObjectMatches().add(ret);
		return ret;
	}
979598
def clone_and_change_target_type(self, base, type):
        """"""
        assert isinstance(base, basestring)
        assert isinstance(type, basestring)
        target_types = []
        for t in self.target_types_and_names_:
            m = _re_match_type.match(t)
            assert m

            if m.group(1) == base:
                if m.group(2):
                    target_types.append(type + m.group(2))
                else:
                    target_types.append(type)
            else:
                target_types.append(t)

        return self.__class__(self.id_, self.composing_,
                              self.source_types_,
                              target_types,
                              self.requirements_)
1222066
@Nullable
  public static <T> CloseableReference<T> cloneOrNull(@Nullable CloseableReference<T> ref) {
    return (ref != null) ? ref.cloneOrNull() : null;
  }
311956
def project_clone(object_id, input_params={}, always_retry=False, **kwargs):
    
    return DXHTTPRequest('/%s/clone' % object_id, input_params, always_retry=always_retry, **kwargs)
1318694
public ITestCaseGenerator cloneOf()
    {
    TupleGenerator other = new TupleGenerator();
    other.setRandomSeed( getRandomSeed());
    other.setDefaultTupleSize( getDefaultTupleSize());
    other.setCombiners( getCombiners().stream().map( TupleCombiner::cloneOf).collect( toList()));
    return other;
    }