Resolve an instance of the given seeder klass.

        :param klass: The Seeder class
        :type klass: class
162255
def _resolve(self, klass):
        
        resolver = None

        if self._resolver:
            resolver = self._resolver
        elif self._command:
            resolver = self._command.resolver

        instance = klass()
        instance.set_connection_resolver(resolver)

        if self._command:
            instance.set_command(self._command)

        return instance
1175141
public Optional<Field> resolveField(Class<?> someClass) {
        return Classes.from(someClass)
                .traversingSuperclasses()
                .fields()
                .filter(elementAnnotatedWith(Identity.class, true))
                .findFirst();
    }
865837
def _class_type(klass, ancestors=None):
    
    # XXX we have to store ancestors in case we have an ancestor loop
    if klass._type is not None:
        return klass._type
    if _is_metaclass(klass):
        klass._type = "metaclass"
    elif klass.name.endswith("Exception"):
        klass._type = "exception"
    else:
        if ancestors is None:
            ancestors = set()
        klass_name = klass.qname()
        if klass_name in ancestors:
            # XXX we are in loop ancestors, and have found no type
            klass._type = "class"
            return "class"
        ancestors.add(klass_name)
        for base in klass.ancestors(recurs=False):
            name = _class_type(base, ancestors)
            if name != "class":
                if name == "metaclass" and not _is_metaclass(klass):
                    # don't propagate it if the current class
                    # can't be a metaclass
                    continue
                klass._type = base.type
                break
    if klass._type is None:
        klass._type = "class"
    return klass._type
1150822
protected Class resolveClass(ObjectStreamClass classDesc)
            throws IOException, ClassNotFoundException {
        String className = classDesc.getName();
        try {
            return loader.loadClass(className);
        } catch (ClassNotFoundException exp) {
            return super.resolveClass(classDesc);
        }
    }
412788
def register(root_class, klass, *identifiers)
      identifiers.map(&:to_sym).each do |identifier|
        @classes_to_identifiers[root_class][klass] ||= []

        @identifiers_to_classes[root_class][identifier] = klass
        @classes_to_identifiers[root_class][klass] << identifier
      end
    end
213676
@Override
    @FFDCIgnore(ClassNotFoundException.class)
    protected Class<?> resolveClass(ObjectStreamClass klass) throws ClassNotFoundException {
        String name = klass.getName();
        try {
            return resolveClass(name);
        } catch (ClassNotFoundException e) {
            if (name.indexOf('.') == -1) {
                // Manually-implemented Java 7 string switch.
                switch (name.hashCode()) {
                    case 0x3db6c28:
                        if (name.equals("boolean")) {
                            return boolean.class;
                        }
                        break;
                    case 0x2e6108:
                        if (name.equals("byte")) {
                            return byte.class;
                        }
                        break;
                    case 0x685847c:
                        if (name.equals("short")) {
                            return short.class;
                        }
                        break;
                    case 0x2e9356:
                        if (name.equals("char")) {
                            return char.class;
                        }
                        break;
                    case 0x197ef:
                        if (name.equals("int")) {
                            return int.class;
                        }
                        break;
                    case 0x5d0225c:
                        if (name.equals("float")) {
                            return float.class;
                        }
                        break;
                    case 0x32c67c:
                        if (name.equals("long")) {
                            return long.class;
                        }
                        break;
                    case 0xb0f77bd1:
                        if (name.equals("double")) {
                            return double.class;
                        }
                        break;
                }
            }

            throw e;
        }
    }
139098
def must_be_same(self, klass):
        """"""
        if self.__class__ is not klass:
            self.__class__ = klass
            self._morph()
            self.clear()
175730
public function resolveClassFromCache(string $class)
    {
        if($this->cache->has($class)) {
            return $this->cache->get($class);
        }

        $resolved = $this->resolveClass($class);

        //cache class
        $this->store($class, $resolved);

        return $resolved;
    }
327672
public function resolve($class)
    {
        if ($this->getContainer()->has($class)) {
            $seeder = $this->getContainer()->get($class);
        } else {
            $seeder = new $class;
        }

        if (!$seeder instanceof self) {
            throw new \LogicException(sprintf('The seeder "%s" does not extend WouterJ\EloquentBundle\Seeder', get_class($seeder)));
        }
        $seeder->setSfContainer($this->getContainer());

        $this->addSeededClass($seeder);

        return $seeder;
    }
1135486
public <T extends Type> T resolve(String typeName, Class<T> clazz) {
        Type instance = resolve(typeName);
        if (instance == null) {
            return null;
        }
        if (clazz.isAssignableFrom(instance.getClass())) {
            return clazz.cast(instance);
        } else {
            throw new ParserException("Type error: %s of type %s can not be cast to %s",
                    typeName, instance.getClass(), clazz);
        }
    }
548682
@Override
    protected Class resolveClass(ObjectStreamClass classDesc) throws IOException, ClassNotFoundException {
        for (ClassLoader loader : classLoaderRegistration) {
            try {
                return resolveClass(classDesc, loader);
            } catch (ClassNotFoundException e) {
                // ignore
            }
        }
        return super.resolveClass(classDesc);
    }
1186860
def of(self, klass, name="default"):
        
        return FactoryBuilder(
            klass, name, self._definitions, self._faker, self._resolver
        )
1192108
def initialize_coercer(klass)
      coercers[klass] =
        begin
          coercer = Coercer::Object.determine_type(klass) || Coercer::Object
          args    = [ self ]
          args   << config_for(coercer) if coercer.respond_to?(:config_name)
          coercer.new(*args)
        end
    end
163136
def load(klass):
        
        config = klass()
        for path in klass.CONF_PATHS:
            if os.path.exists(path):
                with open(path, 'r') as conf:
                    config.configure(yaml.safe_load(conf))
        return config
1219461
@Override
  protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
      ClassNotFoundException {
    return Class.forName(desc.getName(), true, loader);
  }
117403
function Resolver(readerType) {
  // Add all fields here so that all resolvers share the same hidden class.
  this._readerType = readerType;
  this._read = null;
  this.itemsType = null;
  this.size = 0;
  this.symbols = null;
  this.valuesType = null;
}
459332
def _resolve(cls, path, factory_file):
        
        variables = {}

        name = factory_file
        factory_file = os.path.join(path, factory_file)

        with open(factory_file) as fh:
            exec(fh.read(), {}, variables)

        klass = variables[inflection.camelize(name)]

        instance = klass()

        return instance