aliyun-openapi-cpp-sdk/core/src/ServiceRequest.cc

/*
 * Copyright 1999-2019 Alibaba Cloud All rights reserved.
 *
 * 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.
 */

#include <alibabacloud/core/ServiceRequest.h>
#include <alibabacloud/core/AlibabaCloud.h>

namespace AlibabaCloud {

ServiceRequest::ServiceRequest(const std::string &product,
  const std::string &version) :
  content_(nullptr),
  contentSize_(0),
  params_(),
  product_(product),
  resourcePath_("/"),
  version_(version),
  scheme_("https"),
  connectTimeout_(kInvalidTimeout),
  readTimeout_(kInvalidTimeout) {
}

ServiceRequest::ServiceRequest(const ServiceRequest &other) :
  content_(nullptr),
  contentSize_(other.contentSize_),
  params_(other.params_),
  product_(other.product_),
  resourcePath_(other.resourcePath_),
  version_(other.version_),
  scheme_(other.scheme_),
  connectTimeout_(other.connectTimeout_),
  readTimeout_(other.readTimeout_) {
  setContent(other.content_, other.contentSize_);
}

ServiceRequest::ServiceRequest(ServiceRequest &&other) {
  *this = std::move(other);
}

ServiceRequest& ServiceRequest::operator=(const ServiceRequest &other) {
  if (this != &other) {
    content_ = nullptr;
    contentSize_ = 0;
    params_ = other.params_;
    connectTimeout_ = other.connectTimeout_;
    readTimeout_ = other.readTimeout_;
    setContent(other.content_, other.contentSize_);
  }
  return *this;
}

ServiceRequest& ServiceRequest::operator=(ServiceRequest &&other) {
  if (this != &other)
    *this = std::move(other);
  return *this;
}

ServiceRequest::~ServiceRequest() {
  if (content_)
    delete content_;
}

const char * ServiceRequest::content() const {
  return content_;
}

size_t ServiceRequest::contentSize() const {
  return contentSize_;
}

bool ServiceRequest::hasContent() const {
  return (contentSize_ != 0);
}

void ServiceRequest::setContent(const char * data, size_t size) {
  if (content_)
    delete content_;
  content_ = nullptr;
  contentSize_ = 0;
  if (size) {
    contentSize_ = size;
    content_ = new char[size];
    std::copy(data, data + size, content_);
  }
}

void ServiceRequest::addParameter(const ParameterNameType & name,
  const ParameterValueType & value) {
  setParameter(name, value);
}

ServiceRequest::ParameterValueType ServiceRequest::parameter(
  const ParameterNameType &name)const {
  ParameterCollection::const_iterator it = params_.find(name);
  if (it == params_.end()) {
    return ParameterValueType("");
  }
  return it->second;
}


ServiceRequest::ParameterValueType ServiceRequest::coreParameter(
  const ParameterNameType &name)const {
  return parameter(name);
}

ServiceRequest::ParameterCollection ServiceRequest::parameters() const {
  return params_;
}

void ServiceRequest::removeParameter(const ParameterNameType & name) {
  params_.erase(name);
}

void ServiceRequest::setParameter(const ParameterNameType &name,
  const ParameterValueType &value) {
  params_[name] = value;
}

void ServiceRequest::setCoreParameter(const ParameterNameType &name,
  const ParameterValueType &value) {
  setParameter(name, value);
}


void ServiceRequest::setParameters(const ParameterCollection & params) {
  params_ = params;
}

std::string ServiceRequest::version()const {
  return version_;
}

void ServiceRequest::setVersion(const std::string &version) {
  version_ = version;
}

std::string ServiceRequest::product() const {
  return product_;
}

void ServiceRequest::setProduct(const std::string & product) {
  product_ = product;
}

std::string ServiceRequest::resourcePath() const {
  return resourcePath_;
}

void ServiceRequest::setResourcePath(const std::string & path) {
  resourcePath_ = path;
}

void ServiceRequest::setScheme(const std::string scheme) {
  scheme_ = scheme;
}

std::string ServiceRequest::scheme() const {
  return scheme_;
}

long ServiceRequest::connectTimeout() const{
  return connectTimeout_;
}

long ServiceRequest::readTimeout() const{
  return readTimeout_;
}

void ServiceRequest::setConnectTimeout(const long connectTimeout) {
  connectTimeout_ = connectTimeout;
}

void ServiceRequest::setReadTimeout(const long readTimeout) {
  readTimeout_ = readTimeout;
}

}  // namespace AlibabaCloud