LCOV - code coverage report
Current view: top level - eq/fabric - configParams.cpp (source / functions) Hit Total Coverage
Test: Equalizer Lines: 66 89 74.2 %
Date: 2017-12-16 05:07:20 Functions: 26 32 81.2 %

          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/dataIStream.h>
      25             : #include <co/dataOStream.h>
      26             : #include <co/global.h>
      27             : 
      28             : namespace eq
      29             : {
      30             : namespace fabric
      31             : {
      32             : namespace detail
      33             : {
      34          56 : class ConfigParams
      35             : {
      36             : public:
      37           4 :     ConfigParams()
      38           8 :         : flags(eq::fabric::Global::getFlags())
      39           8 :         , prefixes(eq::fabric::Global::getPrefixes())
      40             :     {
      41           4 :         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           4 :             break;
      54             :         default:
      55           0 :             LBUNIMPLEMENTED;
      56             :         }
      57           4 :     }
      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           4 : ConfigParams::ConfigParams()
      72           4 :     : _impl(new detail::ConfigParams)
      73             : {
      74           4 : }
      75             : 
      76          26 : ConfigParams::ConfigParams(const ConfigParams& rhs)
      77          26 :     : _impl(new detail::ConfigParams(*rhs._impl))
      78             : {
      79          26 : }
      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          60 : ConfigParams::~ConfigParams()
      91             : {
      92          30 :     delete _impl;
      93          30 : }
      94             : 
      95           2 : void ConfigParams::setName(const std::string& name)
      96             : {
      97           2 :     _impl->name = name;
      98           2 : }
      99             : 
     100           4 : const std::string& ConfigParams::getName() const
     101             : {
     102           4 :     return _impl->name;
     103             : }
     104             : 
     105           2 : void ConfigParams::setRenderClient(const std::string& renderClient)
     106             : {
     107           2 :     _impl->renderClient = renderClient;
     108             : #ifdef _WIN32 // replace dir delimiters since '\' is often used as escape char
     109             :     std::replace(_impl->renderClient.begin(), _impl->renderClient.end(), '\\',
     110             :                  '/');
     111             : #endif
     112           2 : }
     113             : 
     114           6 : const std::string& ConfigParams::getRenderClient() const
     115             : {
     116           6 :     return _impl->renderClient;
     117             : }
     118             : 
     119           2 : void ConfigParams::setRenderClientArgs(const Strings& args)
     120             : {
     121           2 :     _impl->renderClientArgs = args;
     122           2 : }
     123             : 
     124           4 : const Strings& ConfigParams::getRenderClientArgs() const
     125             : {
     126           4 :     return _impl->renderClientArgs;
     127             : }
     128             : 
     129           0 : void ConfigParams::setRenderClientEnvPrefixes(const Strings& prefixes)
     130             : {
     131           0 :     _impl->renderClientEnvPrefixes = prefixes;
     132           0 : }
     133             : 
     134           2 : const Strings& ConfigParams::getRenderClientEnvPrefixes() const
     135             : {
     136           2 :     return _impl->renderClientEnvPrefixes;
     137             : }
     138             : 
     139           2 : void ConfigParams::setWorkDir(const std::string& workDir)
     140             : {
     141           2 :     _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           2 : }
     146             : 
     147           4 : const std::string& ConfigParams::getWorkDir() const
     148             : {
     149           4 :     return _impl->workDir;
     150             : }
     151             : 
     152           0 : void ConfigParams::setFlags(const uint32_t flags)
     153             : {
     154           0 :     _impl->flags = flags;
     155           0 : }
     156             : 
     157          94 : uint32_t ConfigParams::getFlags() const
     158             : {
     159          94 :     return _impl->flags;
     160             : }
     161             : 
     162           0 : const Equalizer& ConfigParams::getEqualizer() const
     163             : {
     164           0 :     return _impl->equalizer;
     165             : }
     166             : 
     167          42 : Equalizer& ConfigParams::getEqualizer()
     168             : {
     169          42 :     return _impl->equalizer;
     170             : }
     171             : 
     172           0 : void ConfigParams::setPrefixes(const Strings& prefixes)
     173             : {
     174           0 :     _impl->prefixes = prefixes;
     175           0 : }
     176             : 
     177           2 : const Strings& ConfigParams::getPrefixes() const
     178             : {
     179           2 :     return _impl->prefixes;
     180             : }
     181             : 
     182           2 : void ConfigParams::setGPUFilter(const std::string& regex)
     183             : {
     184           2 :     _impl->gpuFilter = regex;
     185           2 : }
     186             : 
     187           4 : const std::string& ConfigParams::getGPUFilter() const
     188             : {
     189           4 :     return _impl->gpuFilter;
     190             : }
     191             : 
     192           2 : void ConfigParams::serialize(co::DataOStream& os) const
     193             : {
     194           2 :     os << _impl->name << _impl->renderClient << _impl->renderClientArgs
     195           6 :        << _impl->renderClientEnvPrefixes << _impl->workDir << _impl->flags
     196           6 :        << _impl->equalizer << _impl->prefixes << _impl->gpuFilter;
     197           2 : }
     198             : 
     199           2 : void ConfigParams::deserialize(co::DataIStream& is)
     200             : {
     201           2 :     is >> _impl->name >> _impl->renderClient >> _impl->renderClientArgs >>
     202           6 :         _impl->renderClientEnvPrefixes >> _impl->workDir >> _impl->flags >>
     203           6 :         _impl->equalizer >> _impl->prefixes >> _impl->gpuFilter;
     204           2 : }
     205             : 
     206           2 : co::DataOStream& operator<<(co::DataOStream& os, const ConfigParams& params)
     207             : {
     208           2 :     params.serialize(os);
     209           2 :     return os;
     210             : }
     211             : 
     212           2 : co::DataIStream& operator>>(co::DataIStream& is, ConfigParams& params)
     213             : {
     214           2 :     params.deserialize(is);
     215           2 :     return is;
     216             : }
     217             : }
     218          60 : }

Generated by: LCOV version 1.11