File Coverage

blib/lib/Lingua/Ogmios.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

package Lingua::Ogmios;


our $VERSION='0.011';


use strict;
use warnings;


use File::Path;

use Lingua::Ogmios::Config;
use Lingua::Ogmios::FileManager;
use Lingua::Ogmios::DocumentCollection;
use Lingua::Ogmios::Timer;


my $debug_devel_level = 0;

sub new {
    my $class = shift;
    my %args = @_;

    binmode(STDERR, ":utf8");
    binmode(STDOUT, ":utf8");
    binmode(STDIN, ":utf8");

    warn "\n----\nNew Platform\n" unless $debug_devel_level < 1;

    my $rcfile = "/etc/ogmios/nlpplatform.rc";
    my $config;

    if (exists $args{"rcfile"}) {
	$rcfile = $args{"rcfile"};
    }

    my $NLPPlatform = {
	'Config' => undef,
	'DocumentCollection' => [],
	"timer" => Lingua::Ogmios::Timer->new(),
    };

    bless $NLPPlatform, $class;
    $NLPPlatform->{"timer"}->start;

    $NLPPlatform->load_config($rcfile);

    return $NLPPlatform;

}

sub load_config
{
    my ($self,$rcfile) = @_;

    warn "self = $self\nrcfile=$rcfile\n"  unless $debug_devel_level < 2;

    if ( ! -f $rcfile ) {
	warn "$rcfile does not exist; Configuration is not loaded\n";
	return (-1);
    }

# Read the configuration file

    warn "Setting the configuration file ...\n" unless $debug_devel_level < 1;
    if ((!defined $rcfile) || ($rcfile eq "")) {
 	$rcfile = "/etc/ogmios/nlpplatform.rc";
    }

    $self->{'Config'} = Lingua::Ogmios::Config->new($rcfile);

#     mkpath($config{'ALVISTMP'});
#     return(%config);
}

sub getConfig {
    my ($self) = @_;

    return($self->{Config});
}

sub printConfig {

    my $self = shift @_;

    return($self->getConfig->print(@_));
}

sub printConfigDOT {

    my $self = shift @_;

    return($self->getConfig->printDOT(@_));
}

sub getDocumentCollection {
    my ($self) = @_;

    return($self->{'DocumentCollection'});
}

sub addDocumentCollection {
    my ($self, $documentCollection) = @_;

    push @{$self->getDocumentCollection}, $documentCollection;
}

sub loadData {
    my ($self, $data) = @_;

    my $documentCollection = Lingua::Ogmios::DocumentCollection->new($data, "data");

    $self->addDocumentCollection($documentCollection);
}



sub loadDocuments {

    my ($self, $files) = @_;

    my $file;
    my $type;
    my $Filemanager;

# is a directory
#   foreach do below foreach file

# is a file

#   1. Alvis : a. 1 document (keep in memory)
#              b. N documents
#                  I. Keep all in memory
#                  II. Store temporary in a spool

#                  i. Processing by document
#                  ii. Processing of M documents

#   2. non Alvis, XML : -> Convert to Alvis XML format (1 document - or less often N documents )

#   3. non Alvis, non XML : -> Convertion to Alvis (1 document)

    $Filemanager = Lingua::Ogmios::FileManager->new($self->getConfig->getSupplementaryMagicFile);

    foreach $file (@$files) {
	if ( ! -e $file ) {
	    warn "$file does not exist; File not loaded\n";
	} else {
	    # Type/format of the document
	    if (($self->getConfig->isInputInALVISFormat) || ($Filemanager->getType($file) eq "text/xml ns=http://alvis.info/enriched/")) {
		warn "Document $file is in Alvis XML format\n";
		# Alvis XML format
		my $documentCollection = Lingua::Ogmios::DocumentCollection->new($file, "file", $self->getConfig);

		$self->addDocumentCollection($documentCollection);
	    }

	    # Convert into ALVIS XML
	}

    }
}

sub tokenisation {
    my ($self) = @_;

    my $documentCollection;

    foreach $documentCollection (@{$self->getDocumentCollection}) {
	$documentCollection->tokenisation;
    }
    return(0);
}

sub linguisticProcessing {
    my ($self) = @_;

    my $documentCollection;
    my $processing;
    my $wrapper;


# 	warn "Processing with the wrapper: " . $self->getConfig->getNLPToolFromIndex($self->getConfig->processingTool($processing))->wrapper . "\n";

#     }

    warn "\n";

    my @docset = values(%{$self->getDocumentCollection->[0]->getDocuments});

    my $tool_config;

    my $NLPTool;
    my $position;

    # TODO Externalize the setting of the NLP wrappers;

#     foreach $wrapper ($self->getConfig->getOrderedWrappers) {

    warn "number of process: " . $self->getConfig->getProcessingSetSize . "\n";

    if ($self->getConfig->getProcessingSetSize > 0) {

	$position = 0;
	foreach $processing ($self->getConfig->getOrderedProcessing) {
	    $position++;
	    $tool_config = $self->getConfig->getNLPToolFromIndex($self->getConfig->processingTool($processing));
	    $wrapper = $tool_config->wrapper;

	    warn "[LOG] Processing with the wrapper: " . $wrapper . " ($processing) " . $self->getConfig->processingTool($processing) . "\n";

	    eval "require $wrapper";
	    if ($@) {
		warn $@ . "\n";
		die "Problem while loading wrapper $wrapper - Abort\n\n";
	    } else {
		if ($position == $self->getConfig->getProcessingSetSize) {
		    $position = 'last';
		}
		warn "[LOG] position: $position (" . $self->getConfig->getProcessingSetSize . ")\n";
		$NLPTool = $wrapper->new($tool_config, $self->getConfig->getOgmiosTMPFILE, $self->getConfig->getOgmiosLOGFILE, $position, $self->getConfig->xmloutput_noStdXmlOutput, $self->getConfig->OgmiosOutStream);
		$NLPTool->run(\@docset);
	    }
	}
    }

#     foreach $documentCollection (@{$self->getDocumentCollection}) {
# 	$documentCollection->printDocumentList;
#     }

    # docColl
    # subdocColl
    # docRec
    return(0);
}

sub XMLout {
    my ($self) = @_;

    my $documentCollection;
    my $str;

    $str = "\n";

    foreach $documentCollection (@{$self->getDocumentCollection}) {
	$str .= $documentCollection->XMLout;
    }
    return($str);

}


sub getTimer {
    my ($self) = @_;

    return($self->{'timer'});
}


1;

__END__