Solstice::ImplementationManager - Manages inter-app communication.

  my $manager = Solstice::ImplementationManager->new();
  # The list returned constists of Solstice::ImplementationData objects.
  my $list = $manager->createList({
      person => $solstice_person,
    method => 'methodName',
    args   => \@arguments_to_method,
  });

package Solstice::ImplementationManager;

use 5.006_000;
use strict;
use warnings;

use base qw(Solstice);

use Solstice::List;
use Solstice::Database;

use constant TRUE => 1;
use constant FALSE => 0;

sub new {
    my $obj = shift;
    my $self = bless {}, ref $obj || $obj;

    return $self;
}

sub getToolImplementationManagers {
    my $self = shift;
    $self->_initializeManagers();

    my $list = Solstice::List->new();
    for my $obj (@{$self->{'_tool_managers'}}) {
        $list->push($obj);
    }
    return $list;
}

sub getAppsWithoutManager {
    my $self = shift;
    $self->_initializeManagers();

    my $list = Solstice::List->new();
    for my $obj (@{$self->{'_tools_without_managers'}}) {
        $list->push($obj);
    }
    return $list;
}

sub createList {
    my $self = shift;
    my $input = shift;
    my $factories = $self->getToolImplementationManagers();

    my $method = $input->{'method'};
    my $person = $input->{'person'};
    my $arg_ref = $input->{'args'};

    my $impl_list = Solstice::List->new();

    if (!defined $method or !$method) {
        warn "createList called without a method.  caller: ".join(' ', caller) ."\n";
        return $impl_list; 
    }
    
    my $manager_iterator = $factories->iterator();
    while ($manager_iterator->hasNext()) {
        my $manager = $manager_iterator->next();
        if ($manager->can($method)) {
            my $sub_list = eval { $manager->$method(@$arg_ref); };
            warn $@ if $@;
            if (defined $sub_list && $sub_list) {
                my $iterator = $sub_list->iterator();
                while ($iterator->hasNext()) {
                    $impl_list->push($iterator->next());
                }
            }
        }
    }
    return $impl_list;
}

sub _initializeManagers {
    my $self = shift;
    if (defined $self->{'_initialized_managers'} and $self->{'_initialized_managers'}) {
        return TRUE;
    }

    my @no_manager_apps;
    my @managers;

    my $db = Solstice::Database->new();
    my $db_name = $self->getConfigService()->getDBName();
    
    $db->readQuery('SELECT name, namespace FROM '.$db_name.'.Application');
    while (my $application= $db->fetchRow()) {
        my $name   = $application->{'name'};
        my $prefix = $application->{'namespace'};
        if(defined $prefix && $prefix){
            $prefix .= "::ImplementationManager";

            eval{
                $self->loadModule($prefix);
            };
            if($@){
                push @no_manager_apps, $name;
            }else{
                my $obj = $prefix->new();
                push @managers, $obj;
            }
        }
    }

    $self->{'_tools_without_managers'} = \@no_manager_apps;
    $self->{'_tool_managers'} = \@managers;
    $self->{'_initialized_managers'} = TRUE;

    return TRUE;
}

1;

__END__