mip_configuration.h

Go to the documentation of this file.

/*
 *
 * Copyright (c) Microsoft Corporation.
 * All rights reserved.
 *
 * This code is licensed under the MIT License.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files(the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions :
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
#ifndef API_MIP_MIP_CONFIGURATION_H_
#define API_MIP_MIP_CONFIGURATION_H_
 
#include <map>
#include <memory>
 
#include "mip/cloud_discovery_delegate.h"
#include "mip/common_types.h"
#include "mip/diagnostic_configuration.h"
#include "mip/flighting_feature.h"
#include "mip/json_delegate.h"
#include "mip/logger_delegate.h"
#include "mip/storage_delegate.h"
#include "mip/task_dispatcher_delegate.h"
#include "mip/xml_delegate.h"
 
#if (!defined(SWIG) && !defined(SWIG_DIRECTORS))
#define DEPRECATED(msg) \
[[deprecated(msg)]]
#else
#define DEPRECATED(msg)
#endif
 
#if !defined(SKIP_CACHE_STORAGE_TYPE_IN_MIP_CONFIGURATION)
#define DEPRECATED_FOR_STORAGE_CACHE_TYPE(msg) \
DEPRECATED(msg)
#else
#define DEPRECATED_FOR_STORAGE_CACHE_TYPE(msg)
#endif
 
MIP_NAMESPACE_BEGIN
 
class MipConfiguration {
public:
 
DEPRECATED_FOR_STORAGE_CACHE_TYPE("MipConfiguration(...) is deprecated, use MipConfiguration(const ApplicationInfo&, const std::string&, LogLevel, bool, CacheStorageType)")
  MipConfiguration(
      const ApplicationInfo& appInfo,
      const std::string& path,
      LogLevel thresholdLogLevel,
      bool isOfflineOnly)
      : mAppInfo(appInfo),
        mPath(path),
        mThresholdLogLevel(thresholdLogLevel),
        mIsOfflineOnly(isOfflineOnly),
        mfeatureSettings(),
        mApiLogCacheMaxMessages(1024) { }
 
  MipConfiguration(
      const ApplicationInfo& appInfo,
      const std::string& path,
      LogLevel thresholdLogLevel,
      bool isOfflineOnly,
      CacheStorageType cacheStorageType)
      : mAppInfo(appInfo),
        mPath(path),
        mThresholdLogLevel(thresholdLogLevel),
        mIsOfflineOnly(isOfflineOnly),
        mfeatureSettings(),
        mApiLogCacheMaxMessages(1024) {
      mCacheStorageType = std::make_shared<CacheStorageType>(cacheStorageType);
    }
  const ApplicationInfo&  GetApplicationInfo() const { return mAppInfo; }
 
  const std::string& GetPath() const { return mPath; }
 
  const LogLevel& GetThresholdLogLevel() const { return mThresholdLogLevel; }
 
  bool isOfflineOnly() const { return mIsOfflineOnly; }
  std::shared_ptr<DiagnosticConfiguration> GetDiagnosticConfiguration() const { return mDiagnosticConfiguration; }
 
  void SetDiagnosticConfiguration(const std::shared_ptr<DiagnosticConfiguration>& diagnosticConfiguration) { mDiagnosticConfiguration = diagnosticConfiguration; }
 
  std::shared_ptr<LoggerDelegate> GetLoggerDelegate() const { return mLoggerDelegate; }
 
  void SetLoggerDelegate(const std::shared_ptr<LoggerDelegate>& loggerDelegate) { mLoggerDelegate = loggerDelegate; }
 
  std::shared_ptr<LoggerConfiguration>  GetLoggerConfiguration() const { return mLoggerConfiguration; }
 
  void SetLoggerConfiguration(const std::shared_ptr<LoggerConfiguration>& loggerConfiguration) { mLoggerConfiguration = loggerConfiguration; }
 
  std::shared_ptr<StorageDelegate> GetStorageDelegate() const { return mStorageDelegate; }
 
  void SetStorageDelegate(const std::shared_ptr<StorageDelegate>& storageDelegate) { mStorageDelegate = storageDelegate; }
 
  std::shared_ptr<CacheStorageType> GetCacheStorageType() const { return mCacheStorageType; }
 
  std::shared_ptr<HttpDelegate> GetHttpDelegate() const { return mHttpDelegate; }
 
  void SetHttpDelegate(const std::shared_ptr<HttpDelegate>& httpDelegate) { mHttpDelegate = httpDelegate; }
 
  std::shared_ptr<CloudDiscoveryDelegate> GetCloudDiscoveryDelegate() const { return mCloudDiscoveryDelegate; }
 
  void SetCloudDiscoveryDelegate(const std::shared_ptr<CloudDiscoveryDelegate>& cloudDiscoveryDelegate) { 
    mCloudDiscoveryDelegate = cloudDiscoveryDelegate; 
  }
 
  std::shared_ptr<JsonDelegate> GetJsonDelegate() const {
    return mJsonDelegate;
  }
 
  std::shared_ptr<xml::XmlDelegate> GetXmlDelegate() const { return mXmlDelegate; }  
 
  std::map<FlightingFeature, bool> GetFeatureSettings() const { return mfeatureSettings; }
 
  void SetFeatureSettings(const std::map<FlightingFeature, bool>& featureSettings) { mfeatureSettings = featureSettings; }
 
  size_t GetApiLogCacheMaxMessages() const { return mApiLogCacheMaxMessages; }
 
  void SetApiLogCacheMaxMessages(size_t maxMessages) { mApiLogCacheMaxMessages = maxMessages; }
 
  ~MipConfiguration() { }
 
protected:
  std::shared_ptr<JsonDelegate> mJsonDelegate;
  std::shared_ptr<xml::XmlDelegate> mXmlDelegate;
 
private:
  ApplicationInfo mAppInfo;
  std::string mPath;
  LogLevel mThresholdLogLevel;
  bool mIsOfflineOnly;
  std::shared_ptr<LoggerDelegate> mLoggerDelegate;
  std::shared_ptr<DiagnosticConfiguration> mDiagnosticConfiguration;
  std::shared_ptr<StorageDelegate> mStorageDelegate;
  std::map<FlightingFeature, bool> mfeatureSettings;
  size_t mApiLogCacheMaxMessages;
  std::shared_ptr<HttpDelegate> mHttpDelegate;
  std::shared_ptr<CloudDiscoveryDelegate> mCloudDiscoveryDelegate;
  std::shared_ptr<LoggerConfiguration> mLoggerConfiguration;
  std::shared_ptr<CacheStorageType> mCacheStorageType;
  };
 
MIP_NAMESPACE_END
#endif  // API_MIP_MIP_CONFIGURATION_H_