module superclass_mod
    type superclass
     integer :: i1
    contains
     generic, public :: assignment(=) => copySuperclass
     !generic, public :: print=>printSuperclass
     procedure, private :: copySuperclass
     !procedure, private :: printSuperclass
     procedure :: print => printSuperclass
    end type
 contains
   subroutine copySuperclass(this, from)
   class(superclass), intent (out) :: this
   !class(superclass), intent (in)  :: from
   type(superclass), intent (in)  :: from
    this%i1=from%i1
   print *, '_____________Superclass assignment'
   end subroutine
   subroutine printSuperclass(this)
   class(superclass), intent (in) :: this
    print *, "Superclass: ",this%i1
   end subroutine
end module superclass_mod

module subclass_mod
 use superclass_mod
    type, extends(superclass) :: subclass
     integer :: i2
    contains
     generic, public :: assignment(=) => copySubclass
     !generic, public :: print=>printSubclass
     procedure, private :: copySubclass
     !procedure, private :: printSubclass
     procedure :: print => printSubclass
    end type
 contains
   subroutine copySubclass(this, from)
   class(subclass), intent (out) :: this
   !class(subclass), intent (in)  :: from
   type(subclass), intent (in)  :: from
    !this%i1=from%i1
    call copySuperclass (this, from%superclass) ! just for kicks
    this%i2=from%i2
    print *, '_____________Subclass assignment'
   end subroutine
!
   subroutine printSubclass(this)
   class(subclass), intent (in) :: this
    print *, "Subclass: ",this%i1,this%i2
   end subroutine
end module subclass_mod

module polycontainer_mod
use superclass_mod
use subclass_mod
 type :: box
  class(superclass), pointer :: sc => null()
 end type
 type, public  :: container
   integer :: number
   type(box), allocatable :: data(:)
   !class(superclass), pointer :: data (:)
  contains
   procedure, public ::  init
   procedure, public ::  addValue
   procedure, public ::  printContainer
 end type
 contains
!
 !subroutine init(this,value, temp)
 subroutine init(this, temp)
 class(container), intent (inout)  :: this
 !class(superclass), intent (inout) :: value
 integer, intent(in) :: temp
 !
 this%number =temp
 !allocate(this%data(this%number),mold=value)
 allocate(this%data(this%number))
 end subroutine
 !
 subroutine addValue(this,value,position)
 class(container)  :: this
 class(superclass) :: value
 integer  :: position
 !this%data(position)=value
 allocate(this%data(position)%sc, source=value)
 ! also, need to handle the case this element was already allocated, etc.
 end subroutine
 subroutine printContainer(this)
 class(container), intent (inout)  :: this
 integer :: i
  print *, "Number of elements: ",this%number
  do i=1,this%number
   !call this%data(i)%print()
   if (associated(this%data(i)%sc)) call this%data(i)%sc%print()
  end do
 end subroutine
end module polycontainer_mod

program test
 use superclass_mod
 use subclass_mod
 use polycontainer_mod
 type(superclass) :: sup1,sup2
 type(subclass) :: sub1,sub2
 type(container) :: containerSup, containerSub
!  sub1%i1=2.; sub1%i2=3.
! sub2=sub1
! print *, "Container.."
! call containerSub%init(sub2,2)
! print *, "Before assignment.."
! call containerSub%printContainer()
! call containerSub%addValue(sub2,1)
! print *, "After assignment.."
! call containerSub%printContainer()
print *, "Superclass: "
print *, "Before copy.."
call sup2%print()
sup1%i1=1.
sup2=sup1
print *, "After copy.."
call sup2%print()
print *, "Subclass: "
print *, "Before copy.."
call sub2%print()
sub1%i1=2.; sub1%i2=3.
sub2=sub1
print *, "After copy.."
call sub2%print()
print *, "Sub container.."
!call containerSub%init(sub2,2)
call containerSub%init(2)
print *, "Before assignment.."
call containerSub%printContainer()
call containerSub%addValue(sub2,1)
print *, "After assignment.."
call containerSub%printContainer()
!
 end program