I know out there are a lot of excelent containers, even frameworks almost entirely DI based with good strong IoC classes. However, this doesn't help me to "define" a new pattern. (This is Php code but understandable to anyone)

Supose we have:

//Declares the singleton
class bookSingleton {
   private $author;
   private static $bookInstance;
   private static $isLoaned = FALSE;  

   //The private constructor
   private function __constructor() {
      $this->author = "Onecrappy Writer Ofcheap Novels";
   }

   //Sets the global isLoaned state and also gets self instance
   public static function loanBook() {
      if (self::$isLoaned === FALSE) {
         //Book already taken, so return false
         return FALSE;
      } else {
         //Ok, not loaned, lets instantiate (if needed and loan)
         if (!isset(self::$bookInstance)) {
             self::$bookInstance = new BookSingleton();
         }
         self::$isLoaned = TRUE;
      }
   }

   //Return loaned state to false, so another book reader can take the book
   public function returnBook() {
      $self::$isLoaned = FALSE;
   }

   public function getAuthor() { return $this->author; }
}

Then we get the singelton consumtion class:

//Consumes the Singleton
class BookBorrower() {
   private $borrowedBook;
   private $haveBookState;

   public function __construct() {
     this->haveBookState = FALSE;
   }

   //Use the singelton-pattern behavior
   public function borrowBook() {
      $this->borrowedBook = BookSingleton::loanBook();
      //Check if was successfully borrowed
      if (!this->borrowedBook) {
         $this->haveBookState = FALSE;
      } else {
         $this->haveBookState = TRUE;
      }
   }

   public function returnBook() {
      $this->borrowedBook->returnBook();
      $this->haveBookState = FALSE;   
   }

   public function getBook() {
      if ($this->haveBookState) {
         return "The book is loaned, the author is" . $this->borrowedbook->getAuthor();
      } else {
         return "I don't have the book, perhaps someone else took it";
      }
   }
}

At last, we got a client, to test the behavior

function __autoload($class) {
    require_once $class . '.php';
}

function write ($whatever,$breaks) {

    for($break = 0;$break<$breaks;$break++) {
        $whatever .= "\n";
    }
    echo nl2br($whatever);
}
write("Begin Singleton test", 2);

$borrowerJuan = new BookBorrower();
$borrowerPedro = new BookBorrower();

write("Juan asks for the book", 1);
$borrowerJuan->borrowBook();
write("Book Borrowed? ", 1);
write($borrowerJuan->getAuthorAndTitle(),2);

write("Pedro asks for the book", 1);
$borrowerPedro->borrowBook();
write("Book Borrowed? ", 1);
write($borrowerPedro->getAuthorAndTitle(),2);

write("Juan returns the book", 1);
$borrowerJuan->returnBook();
write("Returned Book Juan? ", 1);
write($borrowerJuan->getAuthorAndTitle(),2);

write("Pedro asks again for the book", 1);
$borrowerPedro->borrowBook();
write("Book Borrowed? ", 1);
write($borrowerPedro->getAuthorAndTitle(),2);

This will end up in the expected behavior:

Begin Singleton test

Juan asks for the book Book Borrowed? The book is loaned, the author is = Onecrappy Writer Ofcheap Novels

Pedro asks for the book Book Borrowed? I don't have the book, perhaps someone else took it

Juan returns the book Returned Book Juan? I don't have the book, perhaps someone else took it

Pedro asks again for the book Book Borrowed? The book is loaned, the author is = Onecrappy Writer Ofcheap Novels

So I want to make a pattern based on the DI technique able to do exactly the same, but without singleton pattern. As far as I'm aware, I KNOW I must inject the book inside "borrowBook" function instead of taking a static instance:

public function borrowBook(BookNonSingleton $book) {
    if (isset($this->borrowedBook) || $book->isLoaned()) {
        $this->haveBook = FALSE;
        return FALSE;
    } else {
        $this->borrowedBook = $book;
        $this->haveBook = TRUE;
        return TRUE;
    }
}

And at the client, just handle the book: $borrowerJuan = new BookBorrower(); $borrowerJuan->borrowBook(new NonSingletonBook()); Etc... and so far so good, BUT... Im taking the responsability of "single instance" to the borrower, instead of keeping that responsability inside the NonSingletonBook, that since it has not anymore a private constructor, can be instantiated as many times... making instances on each call.

So, What does my NonSingletonBook class MUST be in order to never allow borrowers to have this same book twice? (aka) keep the single instance.

Because the dependency injector part of the code (borrower) does not solve me this AT ALL. Is it needed the container with an "asShared" method builder with static behavior? No way to encapsulate this functionallity into the Book itself? "Hey Im a book and I shouldn't be instantiated more than once, I'm unique"