Public: copy everything

 Returns a deep-dup'd copy of this configuration.
 Public: Apply a named override to the current config

 Returns self
509641
def override(name = nil, &block)
      if override = self.class.overrides(name)
        instance_eval(&override)
      else
        raise ArgumentError.new("no override by the name of #{name} has been configured")
      end
      self
    end
1098189
def copy(self):
        
        state_copy = State()
        state_copy._state_dict = copy.deepcopy(self._state_dict)
        return state_copy
657308
def copy(self):
    
    self_copy = self.dup()
    self_copy._scopes = copy.copy(self._scopes)
    return self_copy
139339
def copy(self, key=None):
        
        other = self.__class__(
            redis=self.redis, key=key, writeback=self.writeback
        )
        other.extend(self)

        return other
627195
function _getConfig() {
        var copy = {},
            property;

        for (property in _config) {
            if (_config.hasOwnProperty(property)) {
                copy[property] = _config[property];
            }
        }
 
        return copy;
    }
171169
Configuration copy(Configuration configuration) {
    Configuration copy = new Configuration();
    copy.restoreState(configuration);
    return copy;
  }
203057
def copy(self):
        
        cls = self.__class__
        result = cls.__new__(cls)
        result._default_plugins = dict(self._default_plugins)  # pylint:disable=protected-access
        return result
1323619
def copy(self):
        
        connection = self.connection
        del self.connection
        copied_query = deepcopy(self)
        copied_query.connection = connection
        self.connection = connection
        return copied_query
68642
def clone(self):
        
        obj = self.__class__()
        obj.libs = deepcopy(self.libs)
        return obj
1265146
def copy(self, name=None, prefix=None):
        """"""
        setting = self.__class__.__new__(self.__class__)
        setting.__dict__.update(self.__dict__)
        # Keep the modified flag?
        # setting.modified = False
        if prefix and not setting.is_global:
            flags = setting.flags
            # Prefix a setting
            setting.orig_name = setting.name
            setting.name = '%s_%s' % (prefix, setting.name)
            if flags and flags[-1].startswith('--'):
                setting.flags = ['--%s-%s' % (prefix, flags[-1][2:])]
        if name and not setting.is_global:
            setting.short = '%s application. %s' % (name, setting.short)
        return setting
1273246
def deep_clone(*args, &block)
      options = args[0] || {}

      dictionary = options[:dictionary]
      dictionary ||= {} if options.delete(:use_dictionary)

      kopy = if dictionary
               find_in_dictionary_or_dup(dictionary)
             else
               dup
             end

      deep_exceptions = {}
      if options[:except]
        exceptions = Array.wrap(options[:except])
        exceptions.each do |attribute|
          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
        end
        deep_exceptions = exceptions.select { |e| e.is_a?(Hash) }.inject({}) { |m, h| m.merge(h) }
      end

      deep_onlinesses = {}
      if options[:only]
        onlinesses = Array.wrap(options[:only])
        object_attrs = kopy.attributes.keys.collect(&:to_sym)
        exceptions = object_attrs - onlinesses
        exceptions.each do |attribute|
          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
        end
        deep_onlinesses = onlinesses.select { |e| e.is_a?(Hash) }.inject({}) { |m, h| m.merge(h) }
      end

      kopy.instance_eval { extend ::DeepCloneable::SkipValidations } if options[:validate] == false

      if options[:include]
        normalized_includes_list(options[:include]).each do |association, conditions_or_deep_associations|
          conditions = {}

          if association.is_a? Hash
            conditions_or_deep_associations = association[association.keys.first]
            association = association.keys.first
          end

          if conditions_or_deep_associations.is_a?(Hash)
            conditions_or_deep_associations = conditions_or_deep_associations.dup
            conditions[:if]     = conditions_or_deep_associations.delete(:if)     if conditions_or_deep_associations[:if]
            conditions[:unless] = conditions_or_deep_associations.delete(:unless) if conditions_or_deep_associations[:unless]
          elsif conditions_or_deep_associations.is_a?(Array)
            conditions_or_deep_associations = conditions_or_deep_associations.dup
            conditions_or_deep_associations.delete_if { |entry| conditions.merge!(entry) if entry.is_a?(Hash) && (entry.key?(:if) || entry.key?(:unless)) }
          end

          dup_options = {}
          dup_options[:include] = conditions_or_deep_associations if conditions_or_deep_associations.present?
          dup_options[:except] = deep_exceptions[association] if deep_exceptions[association]
          dup_options[:only] = deep_onlinesses[association] if deep_onlinesses[association]
          dup_options[:dictionary] = dictionary if dictionary

          [:skip_missing_associations, :validate].each do |option|
            dup_options[option] = options[option] if options.key?(option)
          end

          if (association_reflection = self.class.reflect_on_association(association))
            association_type = association_reflection.macro
            association_type = "#{association_type}_through" if association_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)

            duped_object = send(
              "dup_#{association_type}_association",
              { :reflection => association_reflection, :association => association, :copy => kopy, :conditions => conditions, :dup_options => dup_options },
              &block
            )

            kopy.send("#{association}=", duped_object)
          elsif !options[:skip_missing_associations]
            raise ::DeepCloneable::AssociationNotFoundException, "#{self.class}##{association}"
          end
        end
      end

      yield(self, kopy) if block

      kopy
    end
385472
def copy(self, key=None):
        
        other = self.__class__(
            self.__iter__(),
            self.maxlen,
            redis=self.redis,
            key=key,
            writeback=self.writeback,
        )

        return other
809230
def initialize_copy(other)
      @steps = other.steps.map do |step|
        step.class.new(self, *step.args)
      end
      @content = other.content.dup
      @url_attributes = other.url_attributes.dup
    end
1164988
private function copyConfig()
    {
        // copy config
        $this->filesystem->copy($this->basePath . "config/config.php", config_path('titan.php'));
        $this->line("Config Copied: " . config_path('titan.php'));
    }
578892
def copy(self, *args, **kwargs):
        
        self.make_body_seekable()
        env = self.environ.copy()
        new_req = self.__class__(env, *args, **kwargs)
        new_req.copy_body()
        new_req.identity = self.identity
        return new_req
359371
def copy(self):
        
        copied = TransformForest()
        copied.base_frame = copy.deepcopy(self.base_frame)
        copied.transforms = copy.deepcopy(self.transforms)

        return copied
1030578
def deep_copy
      copy = self.dup
      copy.create_command
      copy.serializer    = self.serializer.deep_copy
      copy.deserializer  = self.deserializer.deep_copy
      copy.commands      = self.commands.dup
      copy.libraries     = self.libraries.dup
      copy.bound_objects = self.bound_objects.dup
      copy
    end