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 IGNITION_FUEL_TOOLS_FUELCLIENT_HH_
#define IGNITION_FUEL_TOOLS_FUELCLIENT_HH_

#include <memory>
#include <string>
#include <vector>
#include <ignition/common/URI.hh>

#include "ignition/fuel_tools/ModelIter.hh"
#include "ignition/fuel_tools/RestClient.hh"
#include "ignition/fuel_tools/Result.hh"
#include "ignition/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 ignition
{
  namespace fuel_tools
  {
    class ClientConfig;
    class CollectionIdentifier;
    class FuelClientPrivate;
    class LocalCache;
    class ModelIdentifier;
    class ServerConfig;

    class IGNITION_FUEL_TOOLS_VISIBLE FuelClient
    {
      public: FuelClient();

      public: FuelClient(const ClientConfig &_config,
                         const Rest &_rest = Rest());

      public: IGN_DEPRECATED(6) FuelClient(const ClientConfig &_config,
                                           const Rest &_rest,
                                           LocalCache *_cache);

      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 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 IGN_DEPRECATED(6) DeleteModel(const ModelIdentifier &_id);

      public: Result DeleteUrl(const ignition::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 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);

      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 ignition::fuel_tools::ModelIdentifier &_model,
                  const std::vector<std::string> &_headers);

      public: Result PatchModel(
                  const ignition::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 ignition::fuel_tools::ServerConfig &_serverConfig,
        std::vector<std::string> &_headers) const;

      private: std::unique_ptr<FuelClientPrivate> dataPtr;
    };
  }
}

#ifdef _MSC_VER
#pragma warning(pop)
#endif

#endif