Changes the internal command to an PUT, setting the class to update
and the values to be written.

@param  string $class
@return Command
425465
public function put(array $values, $class, $append = true)
    {
        $commandClass  = $this->getCommandClass('update.put');
        $this->command = new $commandClass($values, $class, $append);

        return $this->command;
    }
70179
private function registerCommand($class, $command)
    {
        $path = 'bpocallaghan.commands.';
        $this->app->singleton($path . $command, function ($app) use ($class) {
            return $app[$class];
        });

        $this->commands($path . $command);
    }
440945
private function executeUpdates($class)
    {
        $className        = $class->getClassName();
        $persister        = $this->getEntityPersister($className);
        $preUpdateInvoke  = $this->listenersInvoker->getSubscribedSystems($class, Events::preUpdate);
        $postUpdateInvoke = $this->listenersInvoker->getSubscribedSystems($class, Events::postUpdate);

        foreach ($this->entityUpdates as $oid => $entity) {
            if ($this->em->getClassMetadata(get_class($entity))->getClassName() !== $className) {
                continue;
            }

            if ($preUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
                $this->listenersInvoker->invoke($class, Events::preUpdate, $entity, new PreUpdateEventArgs($entity, $this->em, $this->getEntityChangeSet($entity)), $preUpdateInvoke);

                $this->recomputeSingleEntityChangeSet($class, $entity);
            }

            if (! empty($this->entityChangeSets[$oid])) {
                $persister->update($entity);
            }

            unset($this->entityUpdates[$oid]);

            if ($postUpdateInvoke !== ListenersInvoker::INVOKE_NONE) {
                $this->listenersInvoker->invoke($class, Events::postUpdate, $entity, new LifecycleEventArgs($entity, $this->em), $postUpdateInvoke);
            }
        }
    }
1152677
private function registerCommand($class, $command)
    {
        $this->app->singleton($this->commandPath . $command, function ($app) use ($class) {
            return $app[$class];
        });

        $this->commands($this->commandPath . $command);
    }
703340
public function setCommand(Command $command) : self
    {
        $this->command = $command;

        if ($this instanceof ConsoleOutput && $this->getErrorOutput() instanceof ErrorOutput) {
            $this->getErrorOutput()->setCommand($command);
        }

        return $this;
    }
107454
public function saveInstance($alias, &$class)
	{
		$alias = strtolower($alias);

		if (array_key_exists($alias, $this->instances))
		{
			unset($this->instances[$alias]);
		}

		$this->instances[$alias] = $class;

		return $this;
	}
1311944
private function loadCommand($class) {
        $controller = new $class();
        if (!is_a($controller, '\\mpf\\cli\\Command')) {
            $this->critical('Command `' . $class . '` must extend \\mpf\\cli\\Command!', array(
                'requestedController' => $this->request()->getController(),
                'requestedModule' => $this->request()->getModule()
            ));
            return null;
        }
        return $controller;
    }
1083508
protected static function override(&$class)
    {
        $map = gplcart_config_get(GC_FILE_CONFIG_COMPILED_OVERRIDE);

        if (isset($map[$class])) {
            $override = end($map[$class]);
            $class = $override;
        }

        return $class;
    }
727209
protected function instantiator(string $class): InstantiatorInterface
    {
        if (isset($this->instantiators[$class])) {
            return $this->instantiators[$class];
        }

        //Potential optimization
        $instantiator = $this->getFactory()->make(
            $this->define($class, self::R_INSTANTIATOR),
            [
                'class'  => $class,
                'orm'    => $this,
                'schema' => $this->define($class, self::R_SCHEMA)
            ]
        );

        //Constructing instantiator and storing it in cache
        return $this->instantiators[$class] = $instantiator;
    }
683862
public function setClass($class, $namespace = '', $argv = null)
    {
        if (2 < func_num_args()) {
            $argv = func_get_args();
            $argv = array_slice($argv, 2);
        }
        
        $methods = [];
        if (is_array($class)) {
            $methods = $class['methods'];
            $class = $class['class'];
        }
        
        $obj = $class;
        if ($this->container->has($class)) {
            $obj = $this->container->get($class);
        }
        
        $reflection = Reflection::reflectClass($obj, $argv, $namespace);
        
        foreach ($reflection->getMethods() as $method) {
            $docComment = $method->getDocComment();
            if (($docComment !== false && (new DocBlockReflection($docComment))->hasTag('invokable')) || in_array($method->getName(), $methods)) {
                $definition = $this->_buildSignature($method, $class);
                $this->addMethodServiceMap($definition);
            }
        }
        
        return $this;
    }
865412
public function install($class)
    {
        if (!in_array(ToolDefinition::class, class_implements($class), true)) {
            throw new \InvalidArgumentException;
        }
        
        $this->runComposer(call_user_func([$class, 'getComposer']));
        $this->updatePhpQaConfig(
            call_user_func([$class, 'getCliName']),
            $class,
            call_user_func([$class, 'getReportName'])
        );
    }
915230
public<T> Put<T> update(Class<T> cls) throws APIException {
		return new Put<T>(this,getDF(cls));
	}
749157
public function addUse($class, $alias = null)
    {
        $as = $alias == null ? (int)(count($this->uses) + 1) : $alias;
        $this->uses[$as] = (string)$class;
        return $this;
    }
317887
function bindTo($class)
    {
        if (!is_object($class))
            throw new \Exception(sprintf(
                'Given class must be an object (%s) given.'
                , \Poirot\Std\flatten($class)
            ));

        $this->_t__bindTo = $class;

        return $this;
    }
1255625
public function add($class=null)
	{
		$class = $this->get_class($class);

		if (!isset($this->reflections[$class]))
			$this->reflections[$class] = new ReflectionClass($class);
			
		return $this;
	}
449356
protected function resolve($class)
    {
        if (isset($this->container)) {
            $instance = $this->container->make($class);

            $instance->setContainer($this->container);
        } else {
            $instance = new $class;
        }

        if (isset($this->command)) {
            $instance->setCommand($this->command);
        }

        return $instance;
    }
940143
public function on($class)
    {
        $this->instance = is_string($class) ? $this->container !== null ? $this->container->make($class) : new $class : $class;
        
        return $this;
    }