gz/fuel_tools/FuelClient.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2017 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
 
#ifndef GZ_FUEL_TOOLS_FUELCLIENT_HH_
#define GZ_FUEL_TOOLS_FUELCLIENT_HH_
 
#include <memory>
#include <string>
#include <tuple>
#include <vector>
#include <gz/common/URI.hh>
 
#include "gz/fuel_tools/ModelIter.hh"
#include "gz/fuel_tools/RestClient.hh"
#include "gz/fuel_tools/Result.hh"
#include "gz/fuel_tools/WorldIter.hh"
 
#ifdef _WIN32
// Disable warning C4251 which is triggered by
// std::unique_ptr
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
 
namespace gz
{
  namespace fuel_tools
  {
    class ClientConfig;
    class CollectionIdentifier;
    class FuelClientPrivate;
    class LocalCache;
    class ModelIdentifier;
    class ServerConfig;
 
    class GZ_FUEL_TOOLS_VISIBLE FuelClient
    {
      public: FuelClient();
 
      public: FuelClient(const ClientConfig &_config,
                         const Rest &_rest = Rest());
 
      public: ~FuelClient();
 
      public: ClientConfig &Config();
 
      public: Result ModelDetails(const ModelIdentifier &_id,
                                  ModelIdentifier &_model) const;
 
      public: Result ModelDetails(const ModelIdentifier &_id,
                  ModelIdentifier &_model,
                  const std::vector<std::string> &_headers) const;
 
 
      public: ModelIter Models(const ServerConfig &_server);
 
      public: ModelIter Models(const ServerConfig &_server) const;
 
      public: Result WorldDetails(const WorldIdentifier &_id,
                                  WorldIdentifier &_world) const;
 
      public: Result WorldDetails(const WorldIdentifier &_id,
                                WorldIdentifier &_world,
                                const std::vector<std::string> &_headers) const;
 
      public: WorldIter Worlds(const ServerConfig &_server) const;
 
      public: ModelIter Models(const ModelIdentifier &_id);
 
      public: ModelIter Models(const ModelIdentifier &_id) const;
 
      public: ModelIter Models(const ModelIdentifier &_id, bool _checkCache);
 
      public: ModelIter Models(const ModelIdentifier &_id,
                               bool _checkCache) const;
 
      public: ModelIter Models(const CollectionIdentifier &_id) const;
 
      public: WorldIter Worlds(const WorldIdentifier &_id) const;
 
      public: WorldIter Worlds(const CollectionIdentifier &_id) const;
 
      public: Result UploadModel(const std::string &_pathToModelDir,
                                 const ModelIdentifier &_id,
                                 const std::vector<std::string> &_headers,
                                 bool _private = false);
 
      public: Result UploadModel(const std::string &_pathToModelDir,
                                 const ModelIdentifier &_id,
                                 const std::vector<std::string> &_headers,
                                 bool _private,
                                 const std::string &_owner);
 
      public: Result DeleteUrl(const gz::common::URI &_uri,
                  const std::vector<std::string> &_headers);
 
      public: Result DownloadModel(const ModelIdentifier &_id);
 
      public: Result DownloadModel(const ModelIdentifier &_id,
                  const std::vector<std::string> &_headers);
 
      public: Result DownloadModel(const ModelIdentifier &_id,
                  const std::vector<std::string> &_headers,
                  std::vector<ModelIdentifier> &_dependencies);
 
      public: Result ModelDependencies(const ModelIdentifier &_id,
                  std::vector<ModelIdentifier> &_dependencies);
 
      public: Result ModelDependencies(
                  const std::vector<ModelIdentifier> &_id,
                  std::vector<ModelIdentifier> &_dependencies);
 
      public: Result DownloadWorld(WorldIdentifier &_id);
 
      public: Result DownloadWorld(WorldIdentifier &_id,
                  const std::vector<std::string> &_headers);
 
      public: Result DownloadModel(const common::URI &_modelUrl,
                                   std::string &_path);
 
      public: Result DownloadWorld(const common::URI &_worldUrl,
                                   std::string &_path);
 
      using ModelResult = std::tuple<ModelIdentifier, Result>;
 
      //    The resulting vector will be at least the size of the _ids input
      //    vector, but may be larger depending on the number of depedencies
      //    downloaded
      public: std::vector<ModelResult> DownloadModels(
                  const std::vector<ModelIdentifier> &_ids,
                  size_t _jobs = 2);
 
      public: Result DownloadWorlds(
                  const std::vector<WorldIdentifier> &_ids,
                  size_t _jobs = 2);
 
      public: Result CachedModel(const common::URI &_modelUrl,
                                 std::string &_path);
 
      public: bool CachedModel(const common::URI &_modelUrl);
 
      public: Result CachedWorld(const common::URI &_worldUrl,
                                 std::string &_path);
 
      public: bool CachedWorld(const common::URI &_worldUrl);
 
      public: Result CachedModelFile(const common::URI &_fileUrl,
                                     std::string &_path);
 
      public: Result CachedWorldFile(const common::URI &_fileUrl,
                                     std::string &_path);
 
      public: bool ParseModelUrl(const common::URI &_modelUrl,
                                 ModelIdentifier &_id);
 
      public: bool ParseWorldUrl(const common::URI &_worldUrl,
                                 WorldIdentifier &_id);
 
      public: bool ParseModelFileUrl(const common::URI &_modelFileUrl,
                                     ModelIdentifier &_id,
                                     std::string &_filePath);
 
      public: bool ParseWorldFileUrl(const common::URI &_worldFileUrl,
                                     WorldIdentifier &_id,
                                     std::string &_filePath);
 
      public: void PopulateLicenses(const ServerConfig &_server);
 
      public: Result PatchModel(
                  const gz::fuel_tools::ModelIdentifier &_model,
                  const std::vector<std::string> &_headers);
 
      public: Result PatchModel(
                  const gz::fuel_tools::ModelIdentifier &_model,
                  const std::vector<std::string> &_headers,
                  const std::string &_pathToModelDir);
 
      public: bool ParseCollectionUrl(const common::URI &_url,
                                      CollectionIdentifier &_id);
 
      public: bool UpdateModels(const std::vector<std::string> &_headers);
 
      public: bool UpdateWorlds(const std::vector<std::string> &_headers);
 
      private: void AddServerConfigParametersToHeaders(
        const gz::fuel_tools::ServerConfig &_serverConfig,
        std::vector<std::string> &_headers) const;
 
      private: std::unique_ptr<FuelClientPrivate> dataPtr;
    };
  }
}
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif