**DEPRECATED**: All incoming SON manipulators.

        .. versionchanged:: 3.5
          Deprecated.

        .. versionadded:: 2.0
184449
def incoming_manipulators(self):
        
        warnings.warn("Database.incoming_manipulators() is deprecated",
                      DeprecationWarning, stacklevel=2)

        return [manipulator.__class__.__name__
                for manipulator in self.__incoming_manipulators]
653257
def incoming_copying_manipulators(self):
        
        warnings.warn("Database.incoming_copying_manipulators() is deprecated",
                      DeprecationWarning, stacklevel=2)

        return [manipulator.__class__.__name__
                for manipulator in self.__incoming_copying_manipulators]
796391
public function snakeToClass() : Manipulator
    {
        $modifiedString = $this->replace('_', ' ')
            ->toLower()
            ->capitalizeEach()
            ->replace(' ', '')
            ->toString();

        return new static($modifiedString);
    }
1334531
def dereference(self):
        
        all = []
        indexes = {}
        for child in self.children:
            child.content(all)
        deplist = DepList()
        for x in all:
            x.qualify()
            midx, deps = x.dependencies()
            item = (x, tuple(deps))
            deplist.add(item)
            indexes[x] = midx
        for x, deps in deplist.sort():
            midx = indexes.get(x)
            if midx is None:
                continue
            d = deps[midx]
            log.debug('(%s) merging %s <== %s', self.tns[1], Repr(x), Repr(d))
            x.merge(d)
328259
def const_missing mod
    if Rib.const_defined?(mod)
      Rib.warn("Using #{mod} is deprecated, please change to Rib::#{mod}",
               "This compatibility layer would be removed in Rib 1.6+",
               "Called: #{caller.first}")
      Rib.const_get(mod)
    else
      super
    end
  end
1128603
public void deoptimizeReverseBranches() {

      for (Instruction instruction = pcHead; instruction != null; instruction = instruction.getNextPC()) {
         if (instruction.isBranch()) {
            final Branch branch = instruction.asBranch();
            if (branch.isReverse()) {
               final Instruction target = branch.getTarget();
               final LinkedList<Branch> list = target.getReverseUnconditionalBranches();
               if ((list != null) && (list.size() > 0) && (list.get(list.size() - 1) != branch)) {
                  final Branch unconditional = list.get(list.size() - 1).asBranch();
                  branch.retarget(unconditional);

               }
            }
         }
      }
   }
720979
def _raise_deprecation_note(deprecated, replacement, soft=False):
    
    error_msg = ("`{deprecated}` is deprecated. Please use `{replacement}`. "
                 "`{deprecated}` will be removed in future versions of "
                 "Ray.".format(deprecated=deprecated, replacement=replacement))
    if soft:
        logger.warning(error_msg)
    else:
        raise DeprecationWarning(error_msg)
183824
def make_prefix(api_version, manipulator, auth_type):
    """"""
    prefix = "%s_%s" % (api_version, manipulator)
    if (auth_type and auth_type != 'none'):
        prefix += '_' + auth_type
    return prefix
17120
function(methodName, sinceVersion, removeVersion, replacementCall) {
      if(window.console && console.log){
        console.log(methodName + ' has been deprecated since ' + sinceVersion +
          ' and will be removed in version ' + removeVersion + '.' +
          ' Use ' + replacementCall + ' instead.');
      }
    }
1003897
def build_up_commands
      local_versions.select{ |v| v > current_version && v <= target_version }
                    .map{ |v| ApplyCommand.new(v) }
    end
245540
def method_missing(method_name, *arguments, &block)
      if method_name.to_s =~ /(actor|target)_(?!type|id).*/
        self.cache.try(:[], method_name.to_s)
      else
        super
      end
    end
789526
async def SetTools(self, agent_tools):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Upgrader',
                   request='SetTools',
                   version=1,
                   params=_params)
        _params['agent-tools'] = agent_tools
        reply = await self.rpc(msg)
        return reply
867385
def yank_version(name, version, options = {})
      ensure_ready!(:authorization)
      url = "gems/#{escape(name)}/versions/#{escape(version)}"
      response = connection.delete(url, options)
      checked_response_body(response)
    end
374334
def outdated
      outdateds = []

      latest_specs.each do |local|
        dependency = Gem::Dependency.new local.name, ">= #{local.version}"

        begin
          fetcher = Gem::SpecFetcher.fetcher
          remotes = fetcher.find_matching dependency
          remotes = remotes.map { |(name, version,_),_| version }
        rescue Gem::RemoteFetcher::FetchError => e
          raise unless fetcher.warn_legacy e do
            require 'rubygems/source_info_cache'

            specs = Gem::SourceInfoCache.search_with_source dependency, true

            remotes = specs.map { |spec,| spec.version }
          end
        end

        latest = remotes.sort.last

        outdateds << local.name if latest and local.version < latest
      end

      outdateds
    end
972414
def remove_son(self, son):
        
        self._sons = [x for x in self._sons if x.node_id != son.node_id]
864135
def _apply_incoming_manipulators(self, son, collection):
        """"""
        for manipulator in self.__incoming_manipulators:
            son = manipulator.transform_incoming(son, collection)
        return son
959990
def _preprocess_successor(self, state, add_guard=True): #pylint:disable=unused-argument
        

        # Next, simplify what needs to be simplified
        if o.SIMPLIFY_EXIT_STATE in state.options:
            state.solver.simplify()
        if o.SIMPLIFY_EXIT_GUARD in state.options:
            state.scratch.guard = state.solver.simplify(state.scratch.guard)
        if o.SIMPLIFY_EXIT_TARGET in state.options:
            state.scratch.target = state.solver.simplify(state.scratch.target)

        # unwrap stuff from SimActionObjects
        state.scratch.target = _raw_ast(state.scratch.target)
        state.scratch.guard = _raw_ast(state.scratch.guard)

        # apply the guard constraint and new program counter to the state
        if add_guard:
            state.add_constraints(state.scratch.guard)
        # trigger inspect breakpoints here since this statement technically shows up in the IRSB as the "next"
        state.regs.ip = state.scratch.target

        # For architectures with no stack pointer, we can't manage a callstack. This has the side effect of breaking
        # SimProcedures that call out to binary code self.call.
        if self.initial_state.arch.sp_offset is not None and not isinstance(state.arch, ArchSoot):
            self._manage_callstack(state)

        if len(self.successors) != 0:
            # This is a fork!
            state._inspect('fork', BP_AFTER)

        # clean up the state
        state.options.discard(o.AST_DEPS)
        state.options.discard(o.AUTO_REFS)