TS.java

Go to the documentation of this file.

/*
 *                         Vortex OpenSplice
 *
 *   This software and documentation are Copyright 2006 to 2021 ADLINK
 *   Technology Limited, its affiliated companies and licensors. All rights
 *   reserved.
 *
 *   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 org.vortex.FACE;

package FACE;

import java.util.logging.Level;
import org.vortex.FACE.*;
import FACE.RETURN_CODE_TYPE;

public class TS {
    private TransportServices impl;

    protected TS() {
    }

    private static class LazyHolder {
        private static final TS INSTANCE = new TS();
    }

    protected static TS getInstance() {
        return LazyHolder.INSTANCE;
    }

    public TransportServices getImpl() {
        return impl;
    }

    public static void Initialize(String configuration,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (return_code == null) {
            return;
        }
        if (TS.getInstance().impl != null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NO_ACTION;
            return;
        }
        Holder<TransportServices> tsHolder = new Holder<TransportServices>();
        org.vortex.FACE.TSFactory.getInstance().getTS(configuration, tsHolder,
                return_code);
        if (return_code.value == FACE.RETURN_CODE_TYPE.NO_ERROR) {
            TS.getInstance().impl = tsHolder.value;
        }
    }

    public static void Create_Connection(String connection_name,
            FACE.MESSAGING_PATTERN_TYPE pattern,
            us.opengroup.FACE.LongHolder connection_id,
            FACE.CONNECTION_DIRECTION_TYPEHolder connection_direction,
            us.opengroup.FACE.IntHolder max_message_size, long timeout,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().impl == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            return;
        }
        TS.getInstance().impl.Create_Connection(connection_name, pattern,
                connection_id,
                connection_direction, max_message_size, timeout, return_code);
    }


    public static void Destroy_Connection(long connection_id,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().impl == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            return;
        }
        TS.getInstance().impl.Destroy_Connection(connection_id, return_code);
    }

    public static void Unregister_Callback(long connection_id,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().impl == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            return;
        }
        TS.getInstance().impl
                .Unregister_Callback(connection_id, return_code);
    }

    public static void Get_Connection_Parameters(
            us.opengroup.FACE.StringHolder connection_name,
            us.opengroup.FACE.LongHolder connection_id,
            FACE.TRANSPORT_CONNECTION_STATUS_TYPEHolder connection_status,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().impl == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            return;
        }
        TS.getInstance().impl.Get_Connection_Parameters(connection_name,
                connection_id,
                connection_status, return_code);
    }

    public static void Receive_Message(long connection_id, long timeout,
            us.opengroup.FACE.LongHolder transaction_id,
            DataTypeHolder message,
            int message_size, FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().getImpl() == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            Logger.getInstance().log("Receive_Message method not available", Level.SEVERE);
            return;
        }
        if (message == null) {
            return_code.value = RETURN_CODE_TYPE.INVALID_PARAM;
            Logger.getInstance().log("Invalid argument message", Level.SEVERE);
            return;
        }
        Holder<DataType> holder = new Holder<DataType>();
        TS.getInstance()
                .getImpl()
                .Receive_Message(connection_id, timeout, transaction_id,
                holder, message_size, return_code);
        message.value = holder.value;
    }

    public static void Send_Message(long connection_id, long timeout,
            us.opengroup.FACE.LongHolder transaction_id,
            DataTypeHolder message,
            us.opengroup.FACE.IntHolder message_size,
            FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().getImpl() == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            Logger.getInstance().log("Send_Message method not available", Level.SEVERE);
            return;
        }
        if (message == null) {
            return_code.value = RETURN_CODE_TYPE.INVALID_PARAM;
            Logger.getInstance().log("Invalid argument message", Level.SEVERE);
            return;
        }
        Holder<DataType> holder = new Holder<DataType>();
        holder.value = message.value;
        TS.getInstance()
                .getImpl()
                .Send_Message(connection_id, timeout,
                transaction_id, holder,
                message_size, return_code);
    }

    public static void Register_Callback(long connection_id, boolean[] waitset,
            DataTypeRead_CallbackHolder data_callback,
            int max_message_size, FACE.RETURN_CODE_TYPEHolder return_code) {
        if (TS.getInstance().getImpl() == null) {
            return_code.value = FACE.RETURN_CODE_TYPE.NOT_AVAILABLE;
            Logger.getInstance().log("Register_Callback method not available", Level.SEVERE);
            return;
        }
        if (data_callback == null) {
            return_code.value = RETURN_CODE_TYPE.INVALID_PARAM;
            Logger.getInstance().log("Invalid argument data_callback", Level.SEVERE);
            return;
        }
        final FACE.DM.IMU_DataRead_CallbackHolder callback = data_callback;

        org.vortex.FACE.Read_CallbackHolder<DataType> holder = new org.vortex.FACE.Read_CallbackHolder<DataType>();
        holder.value = new org.vortex.FACE.Read_Callback<DataType>() {

            @Override
            public void send_event(long transaction_id,
                    Holder<DataType> message, long message_type_id,
                    int message_size, boolean[] waitset,
                    FACE.RETURN_CODE_TYPEHolder return_code) {
                DataTypeHolder holder = new DataTypeHolder();
                holder.value = message.value;
                callback.value.send_event(transaction_id, holder,
                        message_type_id, message_size, waitset, return_code);
            }
        };
        TS.getInstance()
                .getImpl()
                .Register_Callback(connection_id, waitset,
                holder,
                max_message_size, return_code);
    }
}