<?php

namespace SilverStripe\Core\Injector;

/**
 * A class that can be instantiated or replaced via DI
 */
trait Injectable
{

    /**
     * An implementation of the factory method, allows you to create an instance of a class
     *
     * This method will defer class substitution to the Injector API, which can be customised
     * via the Config API to declare substitution classes.
     *
     * This can be called in one of two ways - either calling via the class directly,
     * or calling on Object and passing the class name as the first parameter. The following
     * are equivalent:
     *    $list = DataList::create('SiteTree');
     *    $list = SiteTree::get();
     *
     * @param string $classOrArgument The first argument, or class name (if called directly
     * on Object).
     * @param mixed $argument,... arguments to pass to the constructor
     * @return static
     */
    public static function create($classOrArgument = null, $argument = null)
    {
        $args = func_get_args();

        // Class to create should be the calling class if not Object,
        // otherwise the first parameter
        $class = get_called_class();
        if ($class == 'SilverStripe\\Core\\Object') {
            $class = array_shift($args);
        }

        return Injector::inst()->createWithArgs($class, $args);
    }

    /**
     * Creates a class instance by the "singleton" design pattern.
     * It will always return the same instance for this class,
     * which can be used for performance reasons and as a simple
     * way to access instance methods which don't rely on instance
     * data (e.g. the custom SilverStripe static handling).
     *
     * @param string $class Optional classname to create, if the called class should not be used
     * @return static The singleton instance
     */
    public static function singleton($class = null)
    {
        if (!$class) {
            $class = get_called_class();
        }
        return Injector::inst()->get($class);
    }
}