FpgaManager_Types.h

#pragma once

// ================================================================================
// PUBLIC INCLUDES
// ================================================================================

#include <cstdio>
#include <string>
#include <ostream>
#include <iomanip>


// ================================================================================
// NAMESPACE
// ================================================================================

namespace enclustra {
namespace fpgamanager {
namespace types {

// ================================================================================
// API URL 
// ================================================================================

struct ApiUrl
{
  enum class Protocol
  {
    Unknown,
    UDP,
    USB2,
    USB3,
    PCIe
  };

  static ApiUrl UDP(const std::string& ipString);
  static ApiUrl FX3(int vendor, int product);
  static ApiUrl FX3(int vendor, int product, int index);
  static ApiUrl FX3Default();
  static ApiUrl FTDI(const std::string& serialNo);
  static ApiUrl PCIeDefault();
  static ApiUrl PCIe(int deviceIndex);

  static ApiUrl Parse(const std::string& url);

  const std::string& str() const;
  Protocol protocol() const;

private:
  ApiUrl(Protocol protocol, const std::string& url);
  std::string _url;
  Protocol _protocol;
};

// ================================================================================
// DURATION
// ================================================================================

struct Duration
{
  static Duration Zero();
  static Duration FromSeconds(unsigned value);
  static Duration FromMilliseconds(unsigned value);
  operator uint32_t() const;

  Duration();
private:
  Duration(uint32_t);
  uint32_t _milliseconds;
};

// ================================================================================
// VERSION
// ================================================================================

template<typename T, std::size_t N>
struct Version
{
        T value[N];

        bool operator ==(const Version<T, N>& that) const
        {
                for (std::size_t idx = 0; idx < N; ++idx)
                        if (value[idx] != that.value[idx])
                                return false;
                return true;
        }

        T& operator[](int idx)
        {
                return value[idx];
        }

        const T& operator[](int idx) const
        {
                return value[idx];
        }
};

template<std::size_t N>
std::ostream& operator<<(std::ostream& lhs, const Version<uint8_t, N>& rhs)
{
  for (std::size_t idx = 0; idx < N; ++idx)
  {
    if (idx) lhs << '.' << std::setw(2) << std::setfill('0');
    lhs << static_cast<int>(rhs.value[idx]);
  }

  return lhs;
}

template<typename T, std::size_t N>
std::ostream& operator<<(std::ostream& lhs, const Version<T, N>& rhs)
{
  for (std::size_t idx = 0; idx < N; ++idx)
  {
    if (idx) lhs << '.' << std::setw(2) << std::setfill('0');
    lhs << rhs.value[idx];
  }

  return lhs;
}

// ================================================================================
// DETAILS
// ================================================================================

struct ApiDetails
{
  types::Version<uint8_t, 3> wrapper_version;
  types::Version<uint8_t, 2> base_dll_version;
};

std::ostream& operator<<(std::ostream& lhs, const ApiDetails& rhs);


// ================================================================================
// TRAILER
// ================================================================================

}
}
}