LCOV - code coverage report
Current view: top level - eq/fabric - configParams.cpp (source / functions) Hit Total Coverage
Test: Equalizer Lines: 63 89 70.8 %
Date: 2016-09-29 05:02:09 Functions: 24 32 75.0 %

          Line data    Source code
       1             : 
       2             : /* Copyright (c) 2005-2016, Stefan Eilemann <eile@equalizergraphics.com>
       3             :  *                          Daniel Nachbaur <danielnachbaur@gmail.com>
       4             :  *
       5             :  * This library is free software; you can redistribute it and/or modify it under
       6             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       7             :  * by the Free Software Foundation.
       8             :  *
       9             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      10             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      11             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      12             :  * details.
      13             :  *
      14             :  * You should have received a copy of the GNU Lesser General Public License
      15             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      16             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      17             :  */
      18             : 
      19             : #include "configParams.h"
      20             : 
      21             : #include "equalizer.h"
      22             : #include "global.h"
      23             : 
      24             : #include <co/dataOStream.h>
      25             : #include <co/dataIStream.h>
      26             : #include <co/global.h>
      27             : 
      28             : namespace eq
      29             : {
      30             : namespace fabric
      31             : {
      32             : namespace detail
      33             : {
      34          16 : class ConfigParams
      35             : {
      36             : public:
      37           8 :     ConfigParams()
      38           8 :         : flags( eq::fabric::Global::getFlags( ))
      39          16 :         , prefixes( eq::fabric::Global::getPrefixes( ))
      40             :     {
      41           8 :         switch( flags & fabric::ConfigParams::FLAG_LOAD_EQ_ALL )
      42             :         {
      43             :             case fabric::ConfigParams::FLAG_LOAD_EQ_2D:
      44           0 :                 equalizer.setMode( fabric::Equalizer::MODE_2D );
      45           0 :                 break;
      46             :             case fabric::ConfigParams::FLAG_LOAD_EQ_HORIZONTAL:
      47           0 :                 equalizer.setMode( fabric::Equalizer::MODE_HORIZONTAL );
      48           0 :                 break;
      49             :             case fabric::ConfigParams::FLAG_LOAD_EQ_VERTICAL:
      50           0 :                 equalizer.setMode( fabric::Equalizer::MODE_VERTICAL );
      51           0 :                 break;
      52             :             case fabric::ConfigParams::FLAG_NONE:
      53           8 :                 break;
      54             :             default:
      55           0 :                 LBUNIMPLEMENTED;
      56             :         }
      57           8 :     }
      58             : 
      59             :     std::string name;
      60             :     std::string renderClient;
      61             :     Strings renderClientArgs;
      62             :     Strings renderClientEnvPrefixes;
      63             :     std::string workDir;
      64             :     uint32_t flags;
      65             :     fabric::Equalizer equalizer;
      66             :     Strings prefixes;
      67             :     std::string gpuFilter;
      68             : };
      69             : }
      70             : 
      71           8 : ConfigParams::ConfigParams()
      72           8 :     : _impl( new detail::ConfigParams )
      73             : {
      74           8 : }
      75             : 
      76           4 : ConfigParams::ConfigParams( const ConfigParams& rhs )
      77           4 :     : _impl( new detail::ConfigParams( *rhs._impl ))
      78             : {
      79           4 : }
      80             : 
      81           0 : ConfigParams& ConfigParams::operator = ( const ConfigParams& rhs )
      82             : {
      83           0 :     if( this == &rhs )
      84           0 :         return *this;
      85             : 
      86           0 :     *_impl = *rhs._impl;
      87           0 :     return *this;
      88             : }
      89             : 
      90          12 : ConfigParams::~ConfigParams()
      91             : {
      92          12 :     delete _impl;
      93          12 : }
      94             : 
      95           4 : void ConfigParams::setName( const std::string& name )
      96             : {
      97           4 :     _impl->name = name;
      98           4 : }
      99             : 
     100           4 : const std::string& ConfigParams::getName() const
     101             : {
     102           4 :     return _impl->name;
     103             : }
     104             : 
     105           4 : void ConfigParams::setRenderClient( const std::string& renderClient )
     106             : {
     107           4 :     _impl->renderClient = renderClient;
     108             : #ifdef _WIN32 // replace dir delimiters since '\' is often used as escape char
     109             :     std::replace( _impl->renderClient.begin(),
     110             :                   _impl->renderClient.end(), '\\', '/' );
     111             : #endif
     112           4 : }
     113             : 
     114          12 : const std::string& ConfigParams::getRenderClient() const
     115             : {
     116          12 :     return _impl->renderClient;
     117             : }
     118             : 
     119           4 : void ConfigParams::setRenderClientArgs( const Strings& args )
     120             : {
     121           4 :     _impl->renderClientArgs = args;
     122           4 : }
     123             : 
     124           8 : const Strings& ConfigParams::getRenderClientArgs() const
     125             : {
     126           8 :     return _impl->renderClientArgs;
     127             : }
     128             : 
     129           0 : void ConfigParams::setRenderClientEnvPrefixes( const Strings& prefixes )
     130             : {
     131           0 :     _impl->renderClientEnvPrefixes = prefixes;
     132           0 : }
     133             : 
     134           4 : const Strings& ConfigParams::getRenderClientEnvPrefixes() const
     135             : {
     136           4 :     return _impl->renderClientEnvPrefixes;
     137             : }
     138             : 
     139           4 : void ConfigParams::setWorkDir( const std::string& workDir )
     140             : {
     141           4 :     _impl->workDir = workDir;
     142             : #ifdef _WIN32 // replace dir delimiters since '\' is often used as escape char
     143             :     std::replace( _impl->workDir.begin(), _impl->workDir.end(), '\\', '/' );
     144             : #endif
     145           4 : }
     146             : 
     147           8 : const std::string& ConfigParams::getWorkDir() const
     148             : {
     149           8 :     return _impl->workDir;
     150             : }
     151             : 
     152           2 : void ConfigParams::setFlags( const uint32_t flags )
     153             : {
     154           2 :     _impl->flags = flags;
     155           2 : }
     156             : 
     157           0 : uint32_t ConfigParams::getFlags() const
     158             : {
     159           0 :     return _impl->flags;
     160             : }
     161             : 
     162           0 : const Equalizer& ConfigParams::getEqualizer() const
     163             : {
     164           0 :     return _impl->equalizer;
     165             : }
     166             : 
     167           0 : Equalizer& ConfigParams::getEqualizer()
     168             : {
     169           0 :     return _impl->equalizer;
     170             : }
     171             : 
     172           0 : void ConfigParams::setPrefixes( const Strings& prefixes )
     173             : {
     174           0 :     _impl->prefixes = prefixes;
     175           0 : }
     176             : 
     177           0 : const Strings& ConfigParams::getPrefixes() const
     178             : {
     179           0 :     return _impl->prefixes;
     180             : }
     181             : 
     182           4 : void ConfigParams::setGPUFilter( const std::string& regex )
     183             : {
     184           4 :     _impl->gpuFilter = regex;
     185           4 : }
     186             : 
     187           4 : const std::string& ConfigParams::getGPUFilter() const
     188             : {
     189           4 :     return _impl->gpuFilter;
     190             : }
     191             : 
     192           4 : void ConfigParams::serialize( co::DataOStream& os ) const
     193             : {
     194           4 :     os << _impl->name << _impl->renderClient << _impl->renderClientArgs
     195           8 :        << _impl->renderClientEnvPrefixes << _impl->workDir << _impl->flags
     196           8 :        << _impl->equalizer << _impl->prefixes << _impl->gpuFilter;
     197           4 : }
     198             : 
     199           4 : void ConfigParams::deserialize( co::DataIStream& is )
     200             : {
     201           4 :     is >> _impl->name >> _impl->renderClient >> _impl->renderClientArgs
     202           8 :        >> _impl->renderClientEnvPrefixes >> _impl->workDir >> _impl->flags
     203           8 :        >> _impl->equalizer >> _impl->prefixes >> _impl->gpuFilter;
     204           4 : }
     205             : 
     206           4 : co::DataOStream& operator << ( co::DataOStream& os, const ConfigParams& params )
     207             : {
     208           4 :     params.serialize( os );
     209           4 :     return os;
     210             : }
     211             : 
     212           4 : co::DataIStream& operator >> ( co::DataIStream& is, ConfigParams& params )
     213             : {
     214           4 :     params.deserialize( is );
     215           4 :     return is;
     216             : }
     217             : 
     218             : }
     219          84 : }

Generated by: LCOV version 1.11