driver.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD 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 General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef DRIVER_H
#define DRIVER_H
 
#include "core/enum_type.hpp"
#include "string_type.h"
 
std::optional<std::string_view> GetDriverParam(const StringList &parm, std::string_view name);
bool GetDriverParamBool(const StringList &parm, std::string_view name);
int GetDriverParamInt(const StringList &parm, std::string_view name, int def);

class Driver {
public:
  virtual std::optional<std::string_view> Start(const StringList &parm) = 0;

  virtual void Stop() = 0;

  virtual ~Driver() = default;

  enum class Type : uint8_t {
    Begin = 0, 
    Music = 0, 
    Sound, 
    Video, 
    End, 
  };

  virtual std::string_view GetName() const = 0;
};
 
DECLARE_INCREMENT_DECREMENT_OPERATORS(Driver::Type)
 
 

class DriverFactoryBase {
private:
  friend class MusicDriver;
  friend class SoundDriver;
  friend class VideoDriver;
 
  Driver::Type type;       
  int priority;            
  std::string_view name;        
  std::string_view description; 
 
  typedef std::map<std::string, DriverFactoryBase *> Drivers; 

  static Drivers &GetDrivers()
  {
    static Drivers &s_drivers = *new Drivers();
    return s_drivers;
  }

  static std::unique_ptr<Driver> &GetActiveDriver(Driver::Type type)
  {
    static std::array<std::unique_ptr<Driver>, to_underlying(Driver::Type::End)> s_driver{};
    return s_driver[to_underlying(type)];
  }

  static std::string_view GetDriverTypeName(Driver::Type type)
  {
    static const std::string_view driver_type_name[] = { "music", "sound", "video" };
    return driver_type_name[to_underlying(type)];
  }
 
  static bool SelectDriverImpl(const std::string &name, Driver::Type type);
 
  static void MarkVideoDriverOperational();
 
protected:
  DriverFactoryBase(Driver::Type type, int priority, std::string_view name, std::string_view description);

  virtual ~DriverFactoryBase();

  virtual bool UsesHardwareAcceleration() const
  {
    return false;
  }
 
public:
  static void ShutdownDrivers()
  {
    for (Driver::Type dt = Driver::Type::Begin; dt != Driver::Type::End; ++dt) {
      auto &driver = GetActiveDriver(dt);
      if (driver != nullptr) driver->Stop();
    }
  }
 
  static void SelectDriver(const std::string &name, Driver::Type type);
  static void GetDriversInfo(std::back_insert_iterator<std::string> &output_iterator);

  std::string_view GetDescription() const
  {
    return this->description;
  }

  virtual std::unique_ptr<Driver> CreateInstance() const = 0;
};
 
#endif /* DRIVER_H */