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::fuel_tools
{
  class ClientConfig;
  class CollectionIdentifier;
  class FuelClientPrivate;
  class LocalCache;
  class ModelIdentifier;
  class ServerConfig;
  class WorldIdentifier;
 
  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 ModelIdentifier &_id,
                               std::string &_path);
 
    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;
  };
}  // namespace gz::fuel_tools
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif  // GZ_FUEL_TOOLS_FUELCLIENT_HH_