vlbi_server.h

/*  OpenVLBI - Open Source Very Long Baseline Interferometry
*   Copyright © 2017-2022  Ilia Platone
*
*   This program is free software; you can redistribute it and/or
*   modify it under the terms of the GNU Lesser General Public
*   License as published by the Free Software Foundation; either
*   version 3 of the License, or (at your option) any later version.
*
*   This program is distributed in the hope that it will be useful,
*   but WITHOUT ANY WARRANTY; without even the implied warranty of
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*   Lesser General Public License for more details.
*
*   You should have received a copy of the GNU Lesser General Public License
*   along with this program; if not, write to the Free Software Foundation,
*   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/
 
#ifndef VLBI_SERVER_H
#define VLBI_SERVER_H
 
#include <vlbi.h>
#include <dsp.h>
 
#ifdef _WIN32
#define restrict __restrict
extern ssize_t getdelim(char **restrict lineptr, size_t *restrict n, int delim, FILE *restrict stream);
#endif
 
namespace VLBI
{
 
typedef enum
{
    plot_flags_moving_baseline = 1,
    plot_flags_uv_coverage = 2,
    plot_flags_synced = 4,
    plot_flags_custom_delegate = 8,
} vlbi_plot_flags;
 
class Server
{
    public:
        Server(void);
        virtual ~Server(void);
 
        virtual int Init(int argc, char** argv)
        {
            (void)argc;
            (void)argv;
            return 1;
        }
 
        virtual void Parse(void);
 
        void addContext(const char *name);
 
        void delContext(const char *name);
 
        void setContext(const char *name);
 
        vlbi_context getContext(void);
 
        inline char* currentContext(void)
        {
            return context;
        }
 
        void addModel(const char *name, char *format, char *b64);
 
        dsp_stream_p getModel(const char *name);
 
        char* getModel(const char *name, char *format);
 
        void delModel(const char *name);
 
        int getModels(char** names);
 
        void addNode(const char *name, char *b64);
 
        void addNodes(const char *name, char *b64);
 
        void addNode(const char *name, dsp_location *locations, void *buf, int len, timespec starttime, bool geo);
 
        void delNode(const char *name);
 
        void CopyNode(const char *name, const char *node);
 
        void Plot(const char *name, int flags);
 
        void Idft(const char *name, const char *magnitude, const char *phase);
 
        void Dft(const char *name, const char *magnitude, const char *phase);
 
        void Mask(const char *name, const char *model, const char *mask);
 
        void Stack(const char *name, const char *model1, const char *model2);
 
        void Copy(const char *name, const char *model);
 
        void Diff(const char *name, const char *model1, const char *model2);
 
        void Convolute(const char *name, const char *model1, const char *model2);
 
        void LowPass(const char *name, const char *node, double freq);
 
        void HighPass(const char *name, const char *node, double freq);
 
        void BandPass(const char *name, const char *node, double lofreq, double hifreq);
 
        void BandReject(const char *name, const char *node, double lofreq, double hifreq);
 
        void Shift(const char *name);
 
        inline virtual void setRa(double value)
        {
            Ra = value;
        }
 
        inline virtual void setDec(double value)
        {
            Dec = value;
        }
 
        inline virtual void setFreq(double value)
        {
            Freq = value;
        }
 
        inline virtual void setSampleRate(double value)
        {
            SampleRate = value;
        }
 
        inline virtual void setBps(int value)
        {
            Bps = value;
        }
 
        inline virtual void setWidth(int value)
        {
            w = value;
        }
 
        inline virtual void setHeight(int value)
        {
            h = value;
        }
 
        inline double getRa(void)
        {
            return Ra;
        }
 
        inline double getDec(void)
        {
            return Dec;
        }
 
        inline double getFreq(void)
        {
            return Freq;
        }
 
        inline double getSampleRate(void)
        {
            return SampleRate;
        }
 
        void setCorrelationOrder(int order);
 
        inline double getBps(void)
        {
            return Bps;
        }
 
        inline double getWidth(void)
        {
            return w;
        }
 
        inline double getHeight(void)
        {
            return h;
        }
 
        void setInput(FILE* in)
        {
            input = in;
        }
 
        inline FILE* getInput()
        {
            return input;
        }
 
        void setOutput(FILE* out)
        {
            output = out;
        }
 
        inline FILE* getOutput()
        {
            return output;
        }
 
        inline void setDelegate(vlbi_func2_t func)
        {
            delegate = func;
        }
 
        inline vlbi_func2_t getDelegate() { return delegate; }
 
    private:
        vlbi_func2_t delegate;
        double Ra;
        double Dec;
        double Freq;
        double SampleRate;
        int Bps;
        int w;
        int h;
        FILE *input, *output;
        char *context;
        char *tmpdir { nullptr };
};
extern VLBI::Server *server;
};
 
#endif //VLBI_SERVER_H