• Home
• com.metaring
• framework-java-functionality
• 1.2.5
• source code
• AbstractFunctionality.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.metaring.framework.functionality.AbstractFunctionality Maven / Gradle / Ivy

/**
 *    Copyright 2019 MetaRing s.r.l.
 * 
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 * 
 *        http://www.apache.org/licenses/LICENSE-2.0
 * 
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

package com.metaring.framework.functionality;

import static java.util.concurrent.CompletableFuture.completedFuture;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.Executor;
import java.util.function.BiFunction;

import com.ea.async.Async;
import com.metaring.framework.GeneratedCoreType;
import com.metaring.framework.Tools;
import com.metaring.framework.controller.AbstractBaseController;
import com.metaring.framework.exception.ManagedException;
import com.metaring.framework.type.DataRepresentation;
import com.metaring.framework.type.Email;
import com.metaring.framework.type.series.DigitSeries;
import com.metaring.framework.type.series.EmailSeries;
import com.metaring.framework.type.series.RealDigitSeries;
import com.metaring.framework.type.series.TextSeries;
import com.metaring.framework.type.series.TruthSeries;
import com.metaring.framework.util.StringUtil;

@SuppressWarnings("unchecked")
public abstract class AbstractFunctionality extends AbstractBaseController implements Functionality {

    protected static final CompletableFuture end = completedFuture(null);
    protected static final Executor EXECUTOR = FunctionalityControllerManager.INSTANCE;

    private final FunctionalityInfo functionalityInfo;
    private final String functionalityName;
    private final Class outputClass;

    private final List>> steps = new ArrayList<>();

    private final LinkedList queue = new LinkedList<>();

    static {
        Async.init();
    }

    protected AbstractFunctionality(FunctionalityInfo functionalityInfo, Class outputClass) {
        super();
        this.functionalityInfo = functionalityInfo;
        this.functionalityName = "[" + functionalityInfo.getFunctionalityFullyQualifiedName() + "] [";
        this.outputClass = outputClass;
        setLoggerStackPosition();
        fillSteps();
    }

    private final void fillSteps() {
        if (!steps.isEmpty()) {
            return;
        }
        steps.add(null);
        steps.add((input, output) -> {
            try {
                return beforePreConditionCheck(input);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return preConditionCheck(input);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return afterPreConditionCheck(input);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return beforeCall(input);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return call(input);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return afterCall(input, output);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return beforePostConditionCheck(input, output);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return postConditionCheck(input, output);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
        steps.add((input, output) -> {
            try {
                return afterPostConditionCheck(input, output);
            } catch (Exception e) {
                throw new InternalStepExectutionException(e);
            }
        });
    }

    private static final CompletableFuture