ciInterface.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2007
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:  Tim George
// Date:       Jan 2007
//
//
//
#ifndef _CIINTERFACE_H_
#define _CIINTERFACE_H_
#include <fstream>
#include <vector>
#include <stdio.h>

#ifdef WIN32
#include <process.h>
#endif
#include "ciApi.h"

#include "ciSensor.h"
#include "ciXML.h"
#include "ciOptics.h"
#include "ciElectronics.h"
#include "ciDetector.h"
#include "ciSenSim.h"
#include "ciEntity.h"
#include "ciChannel.h"
#include "ciEnvironment.h"
#include "ciMovieMerge.h"
#include "ciMoviePlayer.h"
#include "ciNVtherm.h"
#include "ciOcean.h"
#include "ciScenario.h"
#include "ciSensorList.h"
#include "ciServerClient.h"
#include "ciTerrain.h"
#include "ciTrack.h"
#include "ciSettings.h"
#include "ciSystemTest.h"
#include "ciDataCollection.h"

#ifdef WIN32
#pragma warning (disable : 4251)   //  needs to have dll-interface to be used by clients 
#endif // WIN32

class CI_API ciInterface
{
public:
    // seInterface
    ciInterface();

    // ~seInterface
    virtual ~ciInterface();
    // setSensor
    void setSensor(ciSensor &sensor) { m_sensorData = sensor; }

    // getSensor
    ciSensor & getSensor() { return m_sensorData; }
    //*getSensor
    ciSensor &getSensor(int index) 
   { 
      return m_sensorData[index]; 
   } 
    // setSensor
    void setSensorList(ciSensorList &sensorList) { m_sensorListData = sensorList; }

    // getSensor
    ciSensorList &getSensorList() { return m_sensorListData; }

    // setEntity
    void setEntity(ciEntity &entity) { m_entityData = entity; }

   void setChannel(ciChannel &channel) { m_channelData = channel; }

    // getEntity
    ciEntity &getEntity() { return m_entityData; }
    ciEntity & getEntity(int index) 
   { 
      return m_entityData[index]; 
   }

   ciChannel &getChannel() { return m_channelData; }
    ciChannel & getChannel(int index) { return m_channelData[index]; }


    // setTerrain
    void setTerrain(ciTerrain &terrain) { m_terrainData = terrain; }

    // getTerrain
    ciTerrain &getTerrain() { return m_terrainData; }

    // setEnvironment
    void setEnvironment(ciEnvironment &environment) { m_environmentData = environment; }

    // getEnvironment
    ciEnvironment &getEnvironment() { return m_environmentData; }


    // setEnvironment
    void setSystemTest(ciSystemTest &systemTest) { m_systemTestData = systemTest; }

    // getEnvironment
    ciSystemTest &getSystemTest() { return m_systemTestData; }

    // setScenario
    void setScenario(ciScenario &scenario) { m_scenarioData = scenario; }

    // getScenario
    ciScenario &getScenario() { return m_scenarioData; }



   void setDataCollection(ciDataCollection &dc) { m_dataCollectionData = dc; }
   ciDataCollection &getDataCollection() { return m_dataCollectionData; }


    //setMovieMerge
    void setMovieMerge(ciMovieMerge &movieMerge) {m_movieMergeData = movieMerge;}
    //&getMovieMerge
    ciMovieMerge &getMovieMerge() { return m_movieMergeData; }

    //setOcean
    void setOcean(ciOcean &ocean) { m_oceanData = ocean;}
    //&getOcean
    ciOcean &getOcean(){ return m_oceanData; }

    // setTrack
    void setTrack(ciTrack &track) { m_trackData = track; }

    // getTrack
    ciTrack & getTrack() { return m_trackData; }

    //setSensorEffects
    void setSensorEffects(ciSenSim &senSimData) { m_senSimData = senSimData; }
    //&getSensorEffects
    ciSenSim & getSensorEffects() {return m_senSimData;}

    // setOptics
    void setOptics(ciOptics &opticsData) { m_opticsData = opticsData; }

    // getOptics
    ciOptics &getOptics() { return m_opticsData; }

    // setDetector
    void setDetector(ciDetector &detectorData) { m_detectorData = detectorData; }

    // getDetector
    ciDetector &getDetector() { return m_detectorData; }

    // setElectronics
    void setElectronics(ciElectronics &electronicsData) { m_electronicsData = electronicsData; }

    // getElectronics
    ciElectronics &getElectronics() { return m_electronicsData; }

    ciMoviePlayer & getMoviePlayer(){ return m_moviePlayer;}

    void setMoviePlayer(ciMoviePlayer movieplayer){m_moviePlayer = movieplayer;} 
    // getNetwork

    //&getNetwork
    ciServerClient &getNetwork() { return m_network; }

   ciSettings &getSettings() { return m_settingsData; }

   void setSettings(ciSettings& settingsData) { m_settingsData = settingsData; }

    //
    // loadConfig, saveConfig, parseConfig
    //
    // \par Description:
    // Loads, saves, and parses an XML file
    //
    // \param char* configFile
    // \return bool
    //
    // \param char* configFile
    // \return bool
    //
    // \param clXML xmlDocument
    // 
    bool loadConfig(char* configFile);
    bool loadConfigFromString(const char *configString);          
    bool saveConfig(char* configFile);

   bool saveConfigSigSim(char* configFile);
   bool saveConfigSenSim(char* configFile);
   bool saveConfigEnvironment(char* configFile);
   bool saveConfigGreNrt(char *configFile, int index = 0);
   bool saveConfigGreSTDomain(char *configFile, int index = 0);
   bool saveConfigEntity(char *configFile, int index = -1, bool saveGFE = true);
   bool saveConfigTerrain(char *configFile);

    char *getConfigAsString();
    void parseConfig(clXML& xmlDocument);
   void saveXincludeXML( clXML *xmlDocument );
    bool ParseXMLDocument(clXML& xmlDocument);
    bool saveXMLDocument(clXML *xmlDocument);            
    char *getMovieMergeTestLocation(){ return m_movieMergeTestLocation; }
   bool restoreDefaults(char *configFile);            
   bool ParseXMLRestoreDefaults(clXML& xmlDocument);

   bool loadConfigSenSim(char *configFile);
   bool loadConfigSigSim(char *configFile);
   bool loadConfigEnvironment(char *configFile);
   bool loadConfigGreNrt(char *configFile, int index = 0);
   bool loadConfigGreSTDomain(char *configFile, int index = 0);
   bool loadConfigEntity(char *configFile);
   bool loadConfigTerrain(char *configFile);

    //*getCiInterface
    ciInterface *getCiInterface(){ return this;}

    bool m_use_terrain;
    bool m_use_environment;
    bool m_use_track;
    bool m_use_network;
    bool m_use_scenario;
   bool m_use_dataCollection;
   bool m_use_senSim;
    bool m_use_sensor_list_panel;
    bool m_use_movie_merge;
    bool m_use_movie_player;
    bool m_use_ocean;
   bool m_use_settings;
    int m_use_entity_list;
   int m_use_channel_list;
    int m_use_sensor_list;
    int m_use_detector;
    int m_use_electronics;
    int m_use_optics;
   bool m_use_systemtest;
   bool m_use_xinclude_list;


protected:

    ciSensor m_sensorData; 
    ciSensorList m_sensorListData;  
    ciEntity m_entityData; 
   ciChannel m_channelData;   
    ciTerrain m_terrainData; 
    ciEnvironment m_environmentData; 
    ciTrack m_trackData; 
   ciSystemTest m_systemTestData;
    ciServerClient m_network;
    ciScenario m_scenarioData;
   ciDataCollection m_dataCollectionData;
   ciMovieMerge m_movieMergeData;
    ciMoviePlayer m_moviePlayer;
    ciOcean m_oceanData;
    ciOptics m_opticsData;          
    ciDetector m_detectorData;         
    ciElectronics m_electronicsData;   
    ciSenSim m_senSimData;
   ciSettings m_settingsData;
    char        m_movieMergeTestLocation[512];
   vector<string> m_xincludeData;      /* encapsulate in a ciXinclude class? */
    std::string m_XMLstring;


};

#endif