text:
#include <aws/core/utils/Outcome.h>
#include <aws/core/auth/AWSAuthSigner.h>
#include <aws/core/client/CoreErrors.h>
#include <aws/core/client/RetryStrategy.h>
#include <aws/core/http/HttpClient.h>
#include <aws/core/http/HttpResponse.h>
#include <aws/core/http/HttpClientFactory.h>
#include <aws/core/auth/AWSCredentialsProviderChain.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/utils/memory/stl/AWSStringStream.h>
#include <aws/core/utils/threading/Executor.h>
#include <aws/config/ConfigServiceClient.h>
#include <aws/config/ConfigServiceEndpoint.h>
#include <aws/config/ConfigServiceErrorMarshaller.h>
#include <aws/config/model/DeleteConfigRuleRequest.h>
#include <aws/config/model/DeleteConfigurationRecorderRequest.h>
#include <aws/config/model/DeleteDeliveryChannelRequest.h>
#include <aws/config/model/DeleteEvaluationResultsRequest.h>
#include <aws/config/model/DeliverConfigSnapshotRequest.h>
#include <aws/config/model/DescribeComplianceByConfigRuleRequest.h>
#include <aws/config/model/DescribeComplianceByResourceRequest.h>
#include <aws/config/model/DescribeConfigRuleEvaluationStatusRequest.h>
#include <aws/config/model/DescribeConfigRulesRequest.h>
#include <aws/config/model/DescribeConfigurationRecorderStatusRequest.h>
#include <aws/config/model/DescribeConfigurationRecordersRequest.h>
#include <aws/config/model/DescribeDeliveryChannelStatusRequest.h>
#include <aws/config/model/DescribeDeliveryChannelsRequest.h>
#include <aws/config/model/GetComplianceDetailsByConfigRuleRequest.h>
#include <aws/config/model/GetComplianceDetailsByResourceRequest.h>
#include <aws/config/model/GetComplianceSummaryByResourceTypeRequest.h>
#include <aws/config/model/GetResourceConfigHistoryRequest.h>
#include <aws/config/model/ListDiscoveredResourcesRequest.h>
#include <aws/config/model/PutConfigRuleRequest.h>
#include <aws/config/model/PutConfigurationRecorderRequest.h>
#include <aws/config/model/PutDeliveryChannelRequest.h>
#include <aws/config/model/PutEvaluationsRequest.h>
#include <aws/config/model/StartConfigRulesEvaluationRequest.h>
#include <aws/config/model/StartConfigurationRecorderRequest.h>
#include <aws/config/model/StopConfigurationRecorderRequest.h>

using namespace Aws;
using namespace Aws::Auth;
using namespace Aws::Client;
using namespace Aws::ConfigService;
using namespace Aws::ConfigService::Model;
using namespace Aws::Http;
using namespace Aws::Utils::Json;

static const char* SERVICE_NAME = "config";
static const char* ALLOCATION_TAG = "ConfigServiceClient";

ConfigServiceClient::ConfigServiceClient(const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
        SERVICE_NAME, clientConfiguration.region),
    Aws::MakeShared<ConfigServiceErrorMarshaller>(ALLOCATION_TAG)),
    m_executor(clientConfiguration.executor)
{
  init(clientConfiguration);
}

ConfigServiceClient::ConfigServiceClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
         SERVICE_NAME, clientConfiguration.region),
    Aws::MakeShared<ConfigServiceErrorMarshaller>(ALLOCATION_TAG)),
    m_executor(clientConfiguration.executor)
{
  init(clientConfiguration);
}

ConfigServiceClient::ConfigServiceClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
  const Client::ClientConfiguration& clientConfiguration) :
  BASECLASS(clientConfiguration,
    Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
         SERVICE_NAME, clientConfiguration.region),
    Aws::MakeShared<ConfigServiceErrorMarshaller>(ALLOCATION_TAG)),
    m_executor(clientConfiguration.executor)
{
  init(clientConfiguration);
}

ConfigServiceClient::~ConfigServiceClient()
{
}

void ConfigServiceClient::init(const ClientConfiguration& config)
{
  Aws::StringStream ss;
  ss << SchemeMapper::ToString(config.scheme) << "://";

  if(config.endpointOverride.empty())
  {
    ss << ConfigServiceEndpoint::ForRegion(config.region, config.useDualStack);
  }
  else
  {
    ss << config.endpointOverride;
  }

  m_uri = ss.str();
}

DeleteConfigRuleOutcome ConfigServiceClient::DeleteConfigRule(const DeleteConfigRuleRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DeleteConfigRuleOutcome(NoResult());
  }
  else
  {
    return DeleteConfigRuleOutcome(outcome.GetError());
  }
}

DeleteConfigRuleOutcomeCallable ConfigServiceClient::DeleteConfigRuleCallable(const DeleteConfigRuleRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DeleteConfigRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteConfigRule(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DeleteConfigRuleAsync(const DeleteConfigRuleRequest& request, const DeleteConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DeleteConfigRuleAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DeleteConfigRuleAsyncHelper(const DeleteConfigRuleRequest& request, const DeleteConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DeleteConfigRule(request), context);
}

DeleteConfigurationRecorderOutcome ConfigServiceClient::DeleteConfigurationRecorder(const DeleteConfigurationRecorderRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DeleteConfigurationRecorderOutcome(NoResult());
  }
  else
  {
    return DeleteConfigurationRecorderOutcome(outcome.GetError());
  }
}

DeleteConfigurationRecorderOutcomeCallable ConfigServiceClient::DeleteConfigurationRecorderCallable(const DeleteConfigurationRecorderRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DeleteConfigurationRecorderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteConfigurationRecorder(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DeleteConfigurationRecorderAsync(const DeleteConfigurationRecorderRequest& request, const DeleteConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DeleteConfigurationRecorderAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DeleteConfigurationRecorderAsyncHelper(const DeleteConfigurationRecorderRequest& request, const DeleteConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DeleteConfigurationRecorder(request), context);
}

DeleteDeliveryChannelOutcome ConfigServiceClient::DeleteDeliveryChannel(const DeleteDeliveryChannelRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DeleteDeliveryChannelOutcome(NoResult());
  }
  else
  {
    return DeleteDeliveryChannelOutcome(outcome.GetError());
  }
}

DeleteDeliveryChannelOutcomeCallable ConfigServiceClient::DeleteDeliveryChannelCallable(const DeleteDeliveryChannelRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DeleteDeliveryChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteDeliveryChannel(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DeleteDeliveryChannelAsync(const DeleteDeliveryChannelRequest& request, const DeleteDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DeleteDeliveryChannelAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DeleteDeliveryChannelAsyncHelper(const DeleteDeliveryChannelRequest& request, const DeleteDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DeleteDeliveryChannel(request), context);
}

DeleteEvaluationResultsOutcome ConfigServiceClient::DeleteEvaluationResults(const DeleteEvaluationResultsRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DeleteEvaluationResultsOutcome(DeleteEvaluationResultsResult(outcome.GetResult()));
  }
  else
  {
    return DeleteEvaluationResultsOutcome(outcome.GetError());
  }
}

DeleteEvaluationResultsOutcomeCallable ConfigServiceClient::DeleteEvaluationResultsCallable(const DeleteEvaluationResultsRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DeleteEvaluationResultsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEvaluationResults(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DeleteEvaluationResultsAsync(const DeleteEvaluationResultsRequest& request, const DeleteEvaluationResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DeleteEvaluationResultsAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DeleteEvaluationResultsAsyncHelper(const DeleteEvaluationResultsRequest& request, const DeleteEvaluationResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DeleteEvaluationResults(request), context);
}

DeliverConfigSnapshotOutcome ConfigServiceClient::DeliverConfigSnapshot(const DeliverConfigSnapshotRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DeliverConfigSnapshotOutcome(DeliverConfigSnapshotResult(outcome.GetResult()));
  }
  else
  {
    return DeliverConfigSnapshotOutcome(outcome.GetError());
  }
}

DeliverConfigSnapshotOutcomeCallable ConfigServiceClient::DeliverConfigSnapshotCallable(const DeliverConfigSnapshotRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DeliverConfigSnapshotOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeliverConfigSnapshot(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DeliverConfigSnapshotAsync(const DeliverConfigSnapshotRequest& request, const DeliverConfigSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DeliverConfigSnapshotAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DeliverConfigSnapshotAsyncHelper(const DeliverConfigSnapshotRequest& request, const DeliverConfigSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DeliverConfigSnapshot(request), context);
}

DescribeComplianceByConfigRuleOutcome ConfigServiceClient::DescribeComplianceByConfigRule(const DescribeComplianceByConfigRuleRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeComplianceByConfigRuleOutcome(DescribeComplianceByConfigRuleResult(outcome.GetResult()));
  }
  else
  {
    return DescribeComplianceByConfigRuleOutcome(outcome.GetError());
  }
}

DescribeComplianceByConfigRuleOutcomeCallable ConfigServiceClient::DescribeComplianceByConfigRuleCallable(const DescribeComplianceByConfigRuleRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeComplianceByConfigRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeComplianceByConfigRule(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeComplianceByConfigRuleAsync(const DescribeComplianceByConfigRuleRequest& request, const DescribeComplianceByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeComplianceByConfigRuleAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeComplianceByConfigRuleAsyncHelper(const DescribeComplianceByConfigRuleRequest& request, const DescribeComplianceByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeComplianceByConfigRule(request), context);
}

DescribeComplianceByResourceOutcome ConfigServiceClient::DescribeComplianceByResource(const DescribeComplianceByResourceRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeComplianceByResourceOutcome(DescribeComplianceByResourceResult(outcome.GetResult()));
  }
  else
  {
    return DescribeComplianceByResourceOutcome(outcome.GetError());
  }
}

DescribeComplianceByResourceOutcomeCallable ConfigServiceClient::DescribeComplianceByResourceCallable(const DescribeComplianceByResourceRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeComplianceByResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeComplianceByResource(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeComplianceByResourceAsync(const DescribeComplianceByResourceRequest& request, const DescribeComplianceByResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeComplianceByResourceAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeComplianceByResourceAsyncHelper(const DescribeComplianceByResourceRequest& request, const DescribeComplianceByResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeComplianceByResource(request), context);
}

DescribeConfigRuleEvaluationStatusOutcome ConfigServiceClient::DescribeConfigRuleEvaluationStatus(const DescribeConfigRuleEvaluationStatusRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeConfigRuleEvaluationStatusOutcome(DescribeConfigRuleEvaluationStatusResult(outcome.GetResult()));
  }
  else
  {
    return DescribeConfigRuleEvaluationStatusOutcome(outcome.GetError());
  }
}

DescribeConfigRuleEvaluationStatusOutcomeCallable ConfigServiceClient::DescribeConfigRuleEvaluationStatusCallable(const DescribeConfigRuleEvaluationStatusRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeConfigRuleEvaluationStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeConfigRuleEvaluationStatus(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeConfigRuleEvaluationStatusAsync(const DescribeConfigRuleEvaluationStatusRequest& request, const DescribeConfigRuleEvaluationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeConfigRuleEvaluationStatusAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeConfigRuleEvaluationStatusAsyncHelper(const DescribeConfigRuleEvaluationStatusRequest& request, const DescribeConfigRuleEvaluationStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeConfigRuleEvaluationStatus(request), context);
}

DescribeConfigRulesOutcome ConfigServiceClient::DescribeConfigRules(const DescribeConfigRulesRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeConfigRulesOutcome(DescribeConfigRulesResult(outcome.GetResult()));
  }
  else
  {
    return DescribeConfigRulesOutcome(outcome.GetError());
  }
}

DescribeConfigRulesOutcomeCallable ConfigServiceClient::DescribeConfigRulesCallable(const DescribeConfigRulesRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeConfigRulesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeConfigRules(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeConfigRulesAsync(const DescribeConfigRulesRequest& request, const DescribeConfigRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeConfigRulesAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeConfigRulesAsyncHelper(const DescribeConfigRulesRequest& request, const DescribeConfigRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeConfigRules(request), context);
}

DescribeConfigurationRecorderStatusOutcome ConfigServiceClient::DescribeConfigurationRecorderStatus(const DescribeConfigurationRecorderStatusRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeConfigurationRecorderStatusOutcome(DescribeConfigurationRecorderStatusResult(outcome.GetResult()));
  }
  else
  {
    return DescribeConfigurationRecorderStatusOutcome(outcome.GetError());
  }
}

DescribeConfigurationRecorderStatusOutcomeCallable ConfigServiceClient::DescribeConfigurationRecorderStatusCallable(const DescribeConfigurationRecorderStatusRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeConfigurationRecorderStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeConfigurationRecorderStatus(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeConfigurationRecorderStatusAsync(const DescribeConfigurationRecorderStatusRequest& request, const DescribeConfigurationRecorderStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeConfigurationRecorderStatusAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeConfigurationRecorderStatusAsyncHelper(const DescribeConfigurationRecorderStatusRequest& request, const DescribeConfigurationRecorderStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeConfigurationRecorderStatus(request), context);
}

DescribeConfigurationRecordersOutcome ConfigServiceClient::DescribeConfigurationRecorders(const DescribeConfigurationRecordersRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeConfigurationRecordersOutcome(DescribeConfigurationRecordersResult(outcome.GetResult()));
  }
  else
  {
    return DescribeConfigurationRecordersOutcome(outcome.GetError());
  }
}

DescribeConfigurationRecordersOutcomeCallable ConfigServiceClient::DescribeConfigurationRecordersCallable(const DescribeConfigurationRecordersRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeConfigurationRecordersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeConfigurationRecorders(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeConfigurationRecordersAsync(const DescribeConfigurationRecordersRequest& request, const DescribeConfigurationRecordersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeConfigurationRecordersAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeConfigurationRecordersAsyncHelper(const DescribeConfigurationRecordersRequest& request, const DescribeConfigurationRecordersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeConfigurationRecorders(request), context);
}

DescribeDeliveryChannelStatusOutcome ConfigServiceClient::DescribeDeliveryChannelStatus(const DescribeDeliveryChannelStatusRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeDeliveryChannelStatusOutcome(DescribeDeliveryChannelStatusResult(outcome.GetResult()));
  }
  else
  {
    return DescribeDeliveryChannelStatusOutcome(outcome.GetError());
  }
}

DescribeDeliveryChannelStatusOutcomeCallable ConfigServiceClient::DescribeDeliveryChannelStatusCallable(const DescribeDeliveryChannelStatusRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeDeliveryChannelStatusOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDeliveryChannelStatus(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeDeliveryChannelStatusAsync(const DescribeDeliveryChannelStatusRequest& request, const DescribeDeliveryChannelStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeDeliveryChannelStatusAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeDeliveryChannelStatusAsyncHelper(const DescribeDeliveryChannelStatusRequest& request, const DescribeDeliveryChannelStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeDeliveryChannelStatus(request), context);
}

DescribeDeliveryChannelsOutcome ConfigServiceClient::DescribeDeliveryChannels(const DescribeDeliveryChannelsRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return DescribeDeliveryChannelsOutcome(DescribeDeliveryChannelsResult(outcome.GetResult()));
  }
  else
  {
    return DescribeDeliveryChannelsOutcome(outcome.GetError());
  }
}

DescribeDeliveryChannelsOutcomeCallable ConfigServiceClient::DescribeDeliveryChannelsCallable(const DescribeDeliveryChannelsRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< DescribeDeliveryChannelsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDeliveryChannels(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::DescribeDeliveryChannelsAsync(const DescribeDeliveryChannelsRequest& request, const DescribeDeliveryChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->DescribeDeliveryChannelsAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::DescribeDeliveryChannelsAsyncHelper(const DescribeDeliveryChannelsRequest& request, const DescribeDeliveryChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, DescribeDeliveryChannels(request), context);
}

GetComplianceDetailsByConfigRuleOutcome ConfigServiceClient::GetComplianceDetailsByConfigRule(const GetComplianceDetailsByConfigRuleRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return GetComplianceDetailsByConfigRuleOutcome(GetComplianceDetailsByConfigRuleResult(outcome.GetResult()));
  }
  else
  {
    return GetComplianceDetailsByConfigRuleOutcome(outcome.GetError());
  }
}

GetComplianceDetailsByConfigRuleOutcomeCallable ConfigServiceClient::GetComplianceDetailsByConfigRuleCallable(const GetComplianceDetailsByConfigRuleRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< GetComplianceDetailsByConfigRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetComplianceDetailsByConfigRule(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::GetComplianceDetailsByConfigRuleAsync(const GetComplianceDetailsByConfigRuleRequest& request, const GetComplianceDetailsByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->GetComplianceDetailsByConfigRuleAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::GetComplianceDetailsByConfigRuleAsyncHelper(const GetComplianceDetailsByConfigRuleRequest& request, const GetComplianceDetailsByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, GetComplianceDetailsByConfigRule(request), context);
}

GetComplianceDetailsByResourceOutcome ConfigServiceClient::GetComplianceDetailsByResource(const GetComplianceDetailsByResourceRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return GetComplianceDetailsByResourceOutcome(GetComplianceDetailsByResourceResult(outcome.GetResult()));
  }
  else
  {
    return GetComplianceDetailsByResourceOutcome(outcome.GetError());
  }
}

GetComplianceDetailsByResourceOutcomeCallable ConfigServiceClient::GetComplianceDetailsByResourceCallable(const GetComplianceDetailsByResourceRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< GetComplianceDetailsByResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetComplianceDetailsByResource(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::GetComplianceDetailsByResourceAsync(const GetComplianceDetailsByResourceRequest& request, const GetComplianceDetailsByResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->GetComplianceDetailsByResourceAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::GetComplianceDetailsByResourceAsyncHelper(const GetComplianceDetailsByResourceRequest& request, const GetComplianceDetailsByResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, GetComplianceDetailsByResource(request), context);
}

GetComplianceSummaryByConfigRuleOutcome ConfigServiceClient::GetComplianceSummaryByConfigRule() const
{
  Aws::StringStream ss;
  ss << m_uri << "/";

  JsonOutcome outcome = MakeRequest(ss.str(), HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return GetComplianceSummaryByConfigRuleOutcome(GetComplianceSummaryByConfigRuleResult(outcome.GetResult()));
  }
  else
  {
    return GetComplianceSummaryByConfigRuleOutcome(outcome.GetError());
  }
}

GetComplianceSummaryByConfigRuleOutcomeCallable ConfigServiceClient::GetComplianceSummaryByConfigRuleCallable() const
{
  auto task = Aws::MakeShared< std::packaged_task< GetComplianceSummaryByConfigRuleOutcome() > >(ALLOCATION_TAG, [this](){ return this->GetComplianceSummaryByConfigRule(); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::GetComplianceSummaryByConfigRuleAsync(const GetComplianceSummaryByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, handler, context](){ this->GetComplianceSummaryByConfigRuleAsyncHelper( handler, context ); } );
}

void ConfigServiceClient::GetComplianceSummaryByConfigRuleAsyncHelper(const GetComplianceSummaryByConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, GetComplianceSummaryByConfigRule(), context);
}

GetComplianceSummaryByResourceTypeOutcome ConfigServiceClient::GetComplianceSummaryByResourceType(const GetComplianceSummaryByResourceTypeRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return GetComplianceSummaryByResourceTypeOutcome(GetComplianceSummaryByResourceTypeResult(outcome.GetResult()));
  }
  else
  {
    return GetComplianceSummaryByResourceTypeOutcome(outcome.GetError());
  }
}

GetComplianceSummaryByResourceTypeOutcomeCallable ConfigServiceClient::GetComplianceSummaryByResourceTypeCallable(const GetComplianceSummaryByResourceTypeRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< GetComplianceSummaryByResourceTypeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetComplianceSummaryByResourceType(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::GetComplianceSummaryByResourceTypeAsync(const GetComplianceSummaryByResourceTypeRequest& request, const GetComplianceSummaryByResourceTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->GetComplianceSummaryByResourceTypeAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::GetComplianceSummaryByResourceTypeAsyncHelper(const GetComplianceSummaryByResourceTypeRequest& request, const GetComplianceSummaryByResourceTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, GetComplianceSummaryByResourceType(request), context);
}

GetResourceConfigHistoryOutcome ConfigServiceClient::GetResourceConfigHistory(const GetResourceConfigHistoryRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return GetResourceConfigHistoryOutcome(GetResourceConfigHistoryResult(outcome.GetResult()));
  }
  else
  {
    return GetResourceConfigHistoryOutcome(outcome.GetError());
  }
}

GetResourceConfigHistoryOutcomeCallable ConfigServiceClient::GetResourceConfigHistoryCallable(const GetResourceConfigHistoryRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< GetResourceConfigHistoryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResourceConfigHistory(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::GetResourceConfigHistoryAsync(const GetResourceConfigHistoryRequest& request, const GetResourceConfigHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->GetResourceConfigHistoryAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::GetResourceConfigHistoryAsyncHelper(const GetResourceConfigHistoryRequest& request, const GetResourceConfigHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, GetResourceConfigHistory(request), context);
}

ListDiscoveredResourcesOutcome ConfigServiceClient::ListDiscoveredResources(const ListDiscoveredResourcesRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return ListDiscoveredResourcesOutcome(ListDiscoveredResourcesResult(outcome.GetResult()));
  }
  else
  {
    return ListDiscoveredResourcesOutcome(outcome.GetError());
  }
}

ListDiscoveredResourcesOutcomeCallable ConfigServiceClient::ListDiscoveredResourcesCallable(const ListDiscoveredResourcesRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< ListDiscoveredResourcesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDiscoveredResources(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::ListDiscoveredResourcesAsync(const ListDiscoveredResourcesRequest& request, const ListDiscoveredResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->ListDiscoveredResourcesAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::ListDiscoveredResourcesAsyncHelper(const ListDiscoveredResourcesRequest& request, const ListDiscoveredResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, ListDiscoveredResources(request), context);
}

PutConfigRuleOutcome ConfigServiceClient::PutConfigRule(const PutConfigRuleRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return PutConfigRuleOutcome(NoResult());
  }
  else
  {
    return PutConfigRuleOutcome(outcome.GetError());
  }
}

PutConfigRuleOutcomeCallable ConfigServiceClient::PutConfigRuleCallable(const PutConfigRuleRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< PutConfigRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutConfigRule(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::PutConfigRuleAsync(const PutConfigRuleRequest& request, const PutConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->PutConfigRuleAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::PutConfigRuleAsyncHelper(const PutConfigRuleRequest& request, const PutConfigRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, PutConfigRule(request), context);
}

PutConfigurationRecorderOutcome ConfigServiceClient::PutConfigurationRecorder(const PutConfigurationRecorderRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return PutConfigurationRecorderOutcome(NoResult());
  }
  else
  {
    return PutConfigurationRecorderOutcome(outcome.GetError());
  }
}

PutConfigurationRecorderOutcomeCallable ConfigServiceClient::PutConfigurationRecorderCallable(const PutConfigurationRecorderRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< PutConfigurationRecorderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutConfigurationRecorder(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::PutConfigurationRecorderAsync(const PutConfigurationRecorderRequest& request, const PutConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->PutConfigurationRecorderAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::PutConfigurationRecorderAsyncHelper(const PutConfigurationRecorderRequest& request, const PutConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, PutConfigurationRecorder(request), context);
}

PutDeliveryChannelOutcome ConfigServiceClient::PutDeliveryChannel(const PutDeliveryChannelRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return PutDeliveryChannelOutcome(NoResult());
  }
  else
  {
    return PutDeliveryChannelOutcome(outcome.GetError());
  }
}

PutDeliveryChannelOutcomeCallable ConfigServiceClient::PutDeliveryChannelCallable(const PutDeliveryChannelRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< PutDeliveryChannelOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutDeliveryChannel(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::PutDeliveryChannelAsync(const PutDeliveryChannelRequest& request, const PutDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->PutDeliveryChannelAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::PutDeliveryChannelAsyncHelper(const PutDeliveryChannelRequest& request, const PutDeliveryChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, PutDeliveryChannel(request), context);
}

PutEvaluationsOutcome ConfigServiceClient::PutEvaluations(const PutEvaluationsRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return PutEvaluationsOutcome(PutEvaluationsResult(outcome.GetResult()));
  }
  else
  {
    return PutEvaluationsOutcome(outcome.GetError());
  }
}

PutEvaluationsOutcomeCallable ConfigServiceClient::PutEvaluationsCallable(const PutEvaluationsRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< PutEvaluationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutEvaluations(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::PutEvaluationsAsync(const PutEvaluationsRequest& request, const PutEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->PutEvaluationsAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::PutEvaluationsAsyncHelper(const PutEvaluationsRequest& request, const PutEvaluationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, PutEvaluations(request), context);
}

StartConfigRulesEvaluationOutcome ConfigServiceClient::StartConfigRulesEvaluation(const StartConfigRulesEvaluationRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return StartConfigRulesEvaluationOutcome(StartConfigRulesEvaluationResult(outcome.GetResult()));
  }
  else
  {
    return StartConfigRulesEvaluationOutcome(outcome.GetError());
  }
}

StartConfigRulesEvaluationOutcomeCallable ConfigServiceClient::StartConfigRulesEvaluationCallable(const StartConfigRulesEvaluationRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< StartConfigRulesEvaluationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartConfigRulesEvaluation(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::StartConfigRulesEvaluationAsync(const StartConfigRulesEvaluationRequest& request, const StartConfigRulesEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->StartConfigRulesEvaluationAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::StartConfigRulesEvaluationAsyncHelper(const StartConfigRulesEvaluationRequest& request, const StartConfigRulesEvaluationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, StartConfigRulesEvaluation(request), context);
}

StartConfigurationRecorderOutcome ConfigServiceClient::StartConfigurationRecorder(const StartConfigurationRecorderRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return StartConfigurationRecorderOutcome(NoResult());
  }
  else
  {
    return StartConfigurationRecorderOutcome(outcome.GetError());
  }
}

StartConfigurationRecorderOutcomeCallable ConfigServiceClient::StartConfigurationRecorderCallable(const StartConfigurationRecorderRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< StartConfigurationRecorderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartConfigurationRecorder(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::StartConfigurationRecorderAsync(const StartConfigurationRecorderRequest& request, const StartConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->StartConfigurationRecorderAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::StartConfigurationRecorderAsyncHelper(const StartConfigurationRecorderRequest& request, const StartConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, StartConfigurationRecorder(request), context);
}

StopConfigurationRecorderOutcome ConfigServiceClient::StopConfigurationRecorder(const StopConfigurationRecorderRequest& request) const
{
  Aws::StringStream ss;
  Aws::Http::URI uri = m_uri;
  ss << "/";
 uri.SetPath(uri.GetPath() + ss.str());
  JsonOutcome outcome = MakeRequest(uri, request, HttpMethod::HTTP_POST);
  if(outcome.IsSuccess())
  {
    return StopConfigurationRecorderOutcome(NoResult());
  }
  else
  {
    return StopConfigurationRecorderOutcome(outcome.GetError());
  }
}

StopConfigurationRecorderOutcomeCallable ConfigServiceClient::StopConfigurationRecorderCallable(const StopConfigurationRecorderRequest& request) const
{
  auto task = Aws::MakeShared< std::packaged_task< StopConfigurationRecorderOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopConfigurationRecorder(request); } );
  auto packagedFunction = [task]() { (*task)(); };
  m_executor->Submit(packagedFunction);
  return task->get_future();
}

void ConfigServiceClient::StopConfigurationRecorderAsync(const StopConfigurationRecorderRequest& request, const StopConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  m_executor->Submit( [this, request, handler, context](){ this->StopConfigurationRecorderAsyncHelper( request, handler, context ); } );
}

void ConfigServiceClient::StopConfigurationRecorderAsyncHelper(const StopConfigurationRecorderRequest& request, const StopConfigurationRecorderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
  handler(this, request, StopConfigurationRecorder(request), context);
}


text:
<?php

/**
 * Custom dataobject specifically for Campaign Monitor Field Type
 *
 * @package campaign-monitor-userform
 */
class EditableCustomOption extends DataObject
{

    private static $default_sort = "Sort";

    private static $db = array(
        "Name" => "Varchar(255)",
        "Title" => "Varchar(255)",
        "Default" => "Boolean",
        "Sort" => "Int"
    );

    private static $has_one = array(
        "EditableCampaignMonitorField" => "EditableCampaignMonitorField",
    );

    private static $summary_fields = array(
        'Title',
        'Default'
    );

    /**
     * @param Member $member
     *
     * @return boolean
     */
    public function canEdit($member = null)
    {
        return ($this->EditableCampaignMonitorField()->canEdit($member));
    }

    /**
     * @param Member $member
     *
     * @return boolean
     */
    public function canDelete($member = null)
    {
        return ($this->EditableCampaignMonitorField()->canDelete($member));
    }

    public function getEscapedTitle()
    {
        return Convert::raw2att($this->Title);
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Uses of Class com.thinkaurelius.titan.graphdb.transaction.StandardTransactionBuilder (Titan 1.0.0 API)</title>
<meta name="date" content="2015-09-19">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Uses of Class
com.thinkaurelius.titan.graphdb.transaction.StandardTransactionBuilder

Packages that use StandardTransactionBuilder

Package
Description

com.thinkaurelius.titan.graphdb.database

com.thinkaurelius.titan.graphdb.transaction

Uses of StandardTransactionBuilder in com.thinkaurelius.titan.graphdb.database

Methods in com.thinkaurelius.titan.graphdb.database that return StandardTransactionBuilder

Modifier and Type
Method and Description

StandardTransactionBuilder
StandardTitanGraph.buildTransaction()

Uses of StandardTransactionBuilder in com.thinkaurelius.titan.graphdb.transaction

Methods in com.thinkaurelius.titan.graphdb.transaction that return StandardTransactionBuilder

Modifier and Type
Method and Description

StandardTransactionBuilder
StandardTransactionBuilder.checkExternalVertexExistence(boolean enabled)

StandardTransactionBuilder
StandardTransactionBuilder.checkInternalVertexExistence(boolean enabled)

StandardTransactionBuilder
StandardTransactionBuilder.commitTime(java.time.Instant timestampSinceEpoch)

StandardTransactionBuilder
StandardTransactionBuilder.disableBatchLoading()

StandardTransactionBuilder
StandardTransactionBuilder.enableBatchLoading()

StandardTransactionBuilder
StandardTransactionBuilder.groupName(String p)

StandardTransactionBuilder
StandardTransactionBuilder.logIdentifier(String logName)

StandardTransactionBuilder
StandardTransactionBuilder.readOnly()

StandardTransactionBuilder
StandardTransactionBuilder.threadBound()

StandardTransactionBuilder
StandardTransactionBuilder.vertexCacheSize(int size)

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev

Next

Frames

No Frames

All Classes

Copyright © 2012–2015. All rights reserved.


text:
package com.byteowls.vaadin.chartjs.options.annotation;

import java.io.Serializable;

import com.byteowls.vaadin.chartjs.options.AnnotationOptions;
import com.byteowls.vaadin.chartjs.utils.And;
import com.byteowls.vaadin.chartjs.utils.JUtils;
import com.byteowls.vaadin.chartjs.utils.JsonBuilder;
import elemental.json.Json;
import elemental.json.JsonObject;

public abstract class AbstractAnnotation<A, T> extends And<AnnotationOptions<T>> implements JsonBuilder, Serializable {

    private static final long serialVersionUID = 6861210127684854144L;

    private String type;
    private String id;
    private DrawTime drawTime;

    public AbstractAnnotation(AnnotationOptions<T> parent, String type) {
        super(parent);
        this.type = type;
    }

    public A id(String id) {
        this.id = id;
        return getThis();
    }

    /**
     * Defines when the annotations are drawn.
     * This allows positioning of the annotation relative to the other elements to the graph.
     */
    public A drawTime(DrawTime drawTime) {
        this.drawTime = drawTime;
        return getThis();
    }

    public abstract A getThis();

    @Override
    public JsonObject buildJson() {
        JsonObject map = Json.createObject();
        JUtils.putNotNull(map, "type", type);
        JUtils.putNotNull(map, "id", id);
        if (drawTime != null) {
            JUtils.putNotNull(map, "drawTime", drawTime.name());
        }
        return map;
    }

}


text:
namespace settings {

namespace {

#if BUILDFLAG(IS_CHROMEOS_ASH)
// Triggers a TPM firmware update using the least destructive mode from
// |available_modes|.
void TriggerTPMFirmwareUpdate(
    const std::set<ash::tpm_firmware_update::Mode>& available_modes) {
  using ::ash::tpm_firmware_update::Mode;

  // Decide which update mode to use.
  for (Mode mode :
       {Mode::kPreserveDeviceState, Mode::kPowerwash, Mode::kCleanup}) {
    if (available_modes.count(mode) == 0) {
      continue;
    }

    // Save a TPM firmware update request in local state, which
    // will trigger the reset screen to appear on reboot.
    PrefService* prefs = g_browser_process->local_state();
    prefs->SetBoolean(prefs::kFactoryResetRequested, true);
    prefs->SetInteger(prefs::kFactoryResetTPMFirmwareUpdateMode,
                      static_cast<int>(mode));
    prefs->CommitPendingWrite();
    chrome::AttemptRelaunch();
    return;
  }
}
#endif  // BUILDFLAG(IS_CHROMEOS_ASH)

}  // namespace

BrowserLifetimeHandler::BrowserLifetimeHandler() {}

BrowserLifetimeHandler::~BrowserLifetimeHandler() {}

void BrowserLifetimeHandler::RegisterMessages() {
  web_ui()->RegisterDeprecatedMessageCallback(
      "restart", base::BindRepeating(&BrowserLifetimeHandler::HandleRestart,
                                     base::Unretained(this)));
  web_ui()->RegisterDeprecatedMessageCallback(
      "relaunch", base::BindRepeating(&BrowserLifetimeHandler::HandleRelaunch,
                                      base::Unretained(this)));
#if BUILDFLAG(IS_CHROMEOS_ASH)
  web_ui()->RegisterDeprecatedMessageCallback(
      "signOutAndRestart",
      base::BindRepeating(&BrowserLifetimeHandler::HandleSignOutAndRestart,
                          base::Unretained(this)));
  web_ui()->RegisterDeprecatedMessageCallback(
      "factoryReset",
      base::BindRepeating(&BrowserLifetimeHandler::HandleFactoryReset,
                          base::Unretained(this)));
#endif  // BUILDFLAG(IS_CHROMEOS_ASH)
}

void BrowserLifetimeHandler::HandleRestart(
    const base::ListValue* args) {
  chrome::AttemptRestart();
}

void BrowserLifetimeHandler::HandleRelaunch(
    const base::ListValue* args) {
  chrome::AttemptRelaunch();
}

#if BUILDFLAG(IS_CHROMEOS_ASH)
void BrowserLifetimeHandler::HandleSignOutAndRestart(
    const base::ListValue* args) {
  chrome::AttemptUserExit();
}

void BrowserLifetimeHandler::HandleFactoryReset(
    const base::ListValue* args) {
  base::Value::ConstListView args_list = args->GetList();
  CHECK_EQ(1U, args_list.size());
  bool tpm_firmware_update_requested = args_list[0].GetBool();

  if (tpm_firmware_update_requested) {
    ash::tpm_firmware_update::GetAvailableUpdateModes(
        base::BindOnce(&TriggerTPMFirmwareUpdate), base::TimeDelta());
    return;
  }

  // TODO(crbug.com/891905): Centralize powerwash restriction checks.
  bool allow_powerwash =
      !webui::IsEnterpriseManaged() &&
      !user_manager::UserManager::Get()->IsLoggedInAsGuest() &&
      !user_manager::UserManager::Get()->IsLoggedInAsChildUser();

  if (!allow_powerwash)
    return;

  PrefService* prefs = g_browser_process->local_state();
  prefs->SetBoolean(prefs::kFactoryResetRequested, true);
  prefs->CommitPendingWrite();

  // Perform sign out. Current chrome process will then terminate, new one will
  // be launched (as if it was a restart).
  chrome::AttemptRelaunch();
}
#endif  // BUILDFLAG(IS_CHROMEOS_ASH)

}  // namespace settings


text:
title:  Gesprächsfragen SabbatschulWiki
date:   22/11/2019
---

Gott und der Bund
=================

I: Gemeinschaft
---------------

-   Wofür in den vergangenen Tagen seid ihr dankbar?
-   Im Rückblick auf die Herausforderungen der vergangenen Tage: Wo
    wünscht ihr euch Gebetsunterstützung?
-   Was hat euren Glauben gestärkt oder herausgefordert?
-   In welchen Lebensbereichen möchtet ihr wachsen und wünscht euch
    Unterstützung?
-   Welche eurer Gebetsanliegen möchtet ihr mit der Gruppe teilen?

II: Wir studieren die Bibel
---------------------------

Die Lektion 8 der Studienanleitung ist kein text-, sondern ein
themenorientiertes Studium, weshalb wir uns zuerst mit dem Thema der
Woche und den Tagesthemen beschäftigen wollen. Anschließend werden wir
uns mit den Prinzipien des Bundes Gottes mit uns Menschen und deren
praktischen Anwendungen heute auseinandersetzen.

#### Lektionsübersicht

**Wochenthema:**

Prinzipien des Bundes zwischen Gott und seinem Volk erkennen und diese
für unsere Beziehung mit unserem himmlischen Vater anwenden.

**Tagesthemen:**

-   Sonntag, 17.11: Der von Gott angebotene Bund ist Ausdruck seiner
    Sehnsucht nach einer Beziehung mit uns Menschen.
-   Montag, 18.11.: Die vier Kernelemente des Bundes
-   Dienstag, 19.11.: Die Struktur des Bundes
-   Mittwoch, 20.11.: Die menschliche Seite des Bundes
-   Donnerstag 21.11.: Der Tempel - das Herz der Bundesbeziehung
    zwischen Gott und Mensch

#### Gliederung

**Gottes Sehnsucht nach Beziehung:** Der Autor der Studienanleitung
beschreibt auf Seite 92, Absatz 3, dass Gott nicht nur der Schöpfer des
Menschen ist, sondern dass er von Anfang an eine Beziehung mit ihnen
eingehen wollte und sie deshalb zu einem Bund mit ihm einlädt. Das gilt
nicht nur für nachfolgende Generationen, sondern natürlich auch schon
für Adam und Eva, auf die er auch nach dem Sündenfall zugeht und sie
trotz allem zur Beziehung (Bund) mit ihm einlädt.

Lest die folgenden Verse:

1Mose 1,27.28; 2,1-4 und 15-17; 3,15-21

-   Versucht zu erkennen, welche Angebote, Sehnsüchte, Gebote (usw.)
    Gottes zum Ausdruck kommen.
-   Welche Möglichkeiten, Verpflichtungen usw. erwachsen daraus für den
    Menschen?
-   Welche Prinzipen für einen Bund zwischen Mensch und Gott sind
    erkennbar?

**Die vier Kernelemente des Bundes Gottes**

Auf Seite 94 der Studienanleitung zählt der Autor unter Bezugnahme auf
Jeremia 31,33.34 und Hebräer 8,10-12 vier Kernelemente eines Bundes mit
Gott auf: Heilung, Versöhnung, Auftrag und Rechtfertigung. Lest die
beiden Texte.

-   Welche Bundeselemente erkennt ihr aus den beiden Texten?
-   Wie würdet ihr sie für unsere heutige Zeit formulieren?
-   Welche Relevanz haben die hier formulierten Bundeselemente
    (Prinzipien!?) für uns heute?

**Die Struktur des Bundes**

Auf Seite 96b der Studienanleitung zählt der Autor einige
Strukturelemente biblischer Bünde auf (1) Präambel; (2) geschichtlicher
Vorspann; (3) Bundesgegenstand (Bestimmungen, Gesetze usw.); (4)
Konsequenzen bei Gehorsam bzw. Ungehorsam (Segen und Fluch); (5)
Bundeszeugen und (6) evtl. Sondervereinbarungen bzw. Anhänge.

Vergleicht diese Struktur mit dem Bund, den das Volk mit Gott in Nehemia
9,36-10,2; 10,29-33.40 geschlossen hat.

-   Was war die Situation der Israeliten?
-   Was sind die Ähnlichkeiten und Unterschiede?
    -   Was könnte der Grund dafür sein?
-   [HIER findet ihr ein DIN-A4 - PDF-Dokument mit zwei
    Spalten.](:Medium:Kazmierczak_Hubert_Struktur_des_Bundes.pdf "wikilink")
    In der linken Spalte findet ihr die oben angeführte Bundesstruktur.
    Die rechte Spalte ist leer. Bitte die Gruppenmitglieder einen Bund
    mit Gott zu formulieren (gerne auch ganz lebensnah, authentisch und
    ehrlich).
    -   Zuerst in der linken Spalte nach dem Vorbild der Bibel.
    -   Dann in der rechten Spalte nach einer selbstentworfenen
        Struktur, die ihnen für heute relevant erscheint.
        -   Gib dazu 10-15 Minuten Zeit.
        -   Lade die Gruppenmitglieder ein, ihren Bund mit den anderen
            zu teilen, bzw. von ihren Erfahrungen bei der Abfassung zu
            berichten.
-   Warum ist es auch heute wichtig, sich auf einen Bund mit Gott
    einzulassen?
    -   Welche Rolle gestehe ich Gott ganz praktisch in meinem Leben zu?

**Mein Bundesbeitrag**

In Römer 5,20-6,23 beschreibt Paulus einen sehr intimen, ja
lebensentscheidenden Bund (Text evtl. auszugsweise lesen oder Gedanken
aus diesen Versen in den Teil des selbstformulierten Bundes einbringen).

-   Welche Bundesprinzipien sind hier zu finden?
-   Warum ist der hier beschriebene Bund zwischen Christus und uns so
    entscheidend?
-   Welchen Beitrag zur Verwirklichung dieses Bundes ...
    -   ... leistet Christus?
    -   ... habe ich zu leisten?
-   Worin liegen Segen und Fluch?
-   Wenn ich mir bewusst mache, dass mein Herz, ja mein ganzes Leben ein
    Tempel des Heiligen Geistes ist, welche Auswirkungen hat das dann
    auf mein Bundesverhalten?

***Gesprächstipps:***

Sicher lässt sich nicht die ganze Gliederung umsetzen. Darum entscheide
dich, was dir wichtig ist und welches Ziel du erreichen möchtest. Bei
deiner Gesprächsführung und den notwendigen Entscheidungen bzw. der
Ausarbeitung weiterer persönlicher Fragen wünsche ich dir Gottes Segen.

\

III: Dienst und Mission
-----------------------

**Ideen für Aktivitäten**\
Wir tauschen uns über unsere aktuellen Missionskontakte und -projekte
aus, sammeln neue Ideen und beten um die Führung Gottes zur Erfüllung
unseres Auftrags, Jünger zu machen. Hier gibt es zwei Ideen-Sammlungen:
[Soziale Aktivitäten](Medium:Soziale_Aktivitäten_1.3.pdf "wikilink") |
[Wir alle beteiligen
uns](Medium:Wir_alle_beteiligen_uns_1.2.pdf "wikilink")

**Arbeitshilfe "Gebet + Dienst + Zeugnis"**

Weitere Fragen oder Ideen? - du bist herzlich zur Mitarbeit eingeladen:
<https://wiki.sabbatschule.at>


text: A template for building UI components using Stylus for CSS and Babel for JS.


text:
package mx.edu.um.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import mx.edu.um.Constants;
import org.springframework.context.i18n.LocaleContextHolder;

/**
 * Date Utility Class
 * This is used to convert Strings to Dates and Timestamps
 *
 *

 * View Source
 *

 *
 * @author Matt Raible
 *  Modified by Dan Kibler
 *   to correct time pattern. Minutes should be mm not MM
 * 	(MM is month).
 * @version $Revision: 1.7.2.1 $ $Date: 2006-10-03 12:58:45 -0600 (Tue, 03 Oct 2006) $
 */
public class DateUtil {
    //~ Static fields/initializers =============================================

    private static Log log = LogFactory.getLog(DateUtil.class);
    private static String defaultDatePattern = null;
    private static String timePattern = "HH:mm";

    //~ Methods ================================================================

    /**
     * Return default datePattern (MM/dd/yyyy)
     * @return a string representing the date pattern on the UI
     */
    public static String getDatePattern() {
        Locale locale = LocaleContextHolder.getLocale();
        try {
            defaultDatePattern = ResourceBundle.getBundle(Constants.BUNDLE_KEY, locale)
                .getString("date.format");
        } catch (MissingResourceException mse) {
            defaultDatePattern = "MM/dd/yyyy";
        }

        return defaultDatePattern;
    }

    public static String getDateTimePattern() {
        return DateUtil.getDatePattern() + " HH:mm:ss.S";
    }

    /**
     * This method attempts to convert an Oracle-formatted date
     * in the form dd-MMM-yyyy to mm/dd/yyyy.
     *
     * @param aDate date from database as a string
     * @return formatted string for the ui
     */
    public static final String getDate(Date aDate) {
        SimpleDateFormat df = null;
        String returnValue = "";

        if (aDate != null) {
            df = new SimpleDateFormat(getDatePattern());
            returnValue = df.format(aDate);
        }

        return (returnValue);
    }

    /**
     * This method generates a string representation of a date/time
     * in the format you specify on input
     *
     * @param aMask the date pattern the string is in
     * @param strDate a string representation of a date
     * @return a converted Date object
     * @see java.text.SimpleDateFormat
     * @throws ParseException
     */
    public static final Date convertStringToDate(String aMask, String strDate)
      throws ParseException {
        SimpleDateFormat df = null;
        Date date = null;
        df = new SimpleDateFormat(aMask);

        if (log.isDebugEnabled()) {
            log.debug("converting '" + strDate + "' to date with mask '"
                      + aMask + "'");
        }

        try {
            date = df.parse(strDate);
        } catch (ParseException pe) {
            //log.error("ParseException: " + pe);
            throw new ParseException(pe.getMessage(), pe.getErrorOffset());
        }

        return (date);
    }

    /**
     * This method returns the current date time in the format:
     * MM/dd/yyyy HH:MM a
     *
     * @param theTime the current time
     * @return the current date/time
     */
    public static String getTimeNow(Date theTime) {
        return getDateTime(timePattern, theTime);
    }

    /**
     * This method returns the current date in the format: MM/dd/yyyy
     *
     * @return the current date
     * @throws ParseException
     */
    public static Calendar getToday() throws ParseException {
        Date today = new Date();
        SimpleDateFormat df = new SimpleDateFormat(getDatePattern());

        // This seems like quite a hack (date -> string -> date),
        // but it works ;-)
        String todayAsString = df.format(today);
        Calendar cal = new GregorianCalendar();
        cal.setTime(convertStringToDate(todayAsString));

        return cal;
    }

    /**
     * This method generates a string representation of a date's date/time
     * in the format you specify on input
     *
     * @param aMask the date pattern the string is in
     * @param aDate a date object
     * @return a formatted string representation of the date
     *
     * @see java.text.SimpleDateFormat
     */
    public static final String getDateTime(String aMask, Date aDate) {
        SimpleDateFormat df = null;
        String returnValue = "";

        if (aDate == null) {
            log.error("aDate is null!");
        } else {
            df = new SimpleDateFormat(aMask);
            returnValue = df.format(aDate);
        }

        return (returnValue);
    }

    /**
     * This method generates a string representation of a date based
     * on the System Property 'dateFormat'
     * in the format you specify on input
     *
     * @param aDate A date to convert
     * @return a string representation of the date
     */
    public static final String convertDateToString(Date aDate) {
        return getDateTime(getDatePattern(), aDate);
    }

    /**
     * This method converts a String to a date using the datePattern
     *
     * @param strDate the date to convert (in format MM/dd/yyyy)
     * @return a date object
     *
     * @throws ParseException
     */
    public static Date convertStringToDate(String strDate)
      throws ParseException {
        Date aDate = null;

        try {
            if (log.isDebugEnabled()) {
                log.debug("converting date with pattern: " + getDatePattern());
            }

            aDate = convertStringToDate(getDatePattern(), strDate);
        } catch (ParseException pe) {
            log.error("Could not convert '" + strDate
                      + "' to a date, throwing exception");
            pe.printStackTrace();
            throw new ParseException(pe.getMessage(),
                                     pe.getErrorOffset());

        }

        return aDate;
    }
}


text:
// ***********************************************************************
// Copyright (c) 2016 Charlie Poole
//
// 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.
// ***********************************************************************

using System;
using System.Collections.Generic;

namespace NUnit.Engine.Extensibility
{
    /// <summary>
    /// An ExtensionPoint represents a single point in the TestEngine
    /// that may be extended by user addins and extensions.
    /// </summary>
    public interface IExtensionPoint
    {
        /// <summary>
        /// Gets the unique path identifying this extension point.
        /// </summary>
        string Path { get; }

        /// <summary>
        /// Gets the description of this extension point. May be null.
        /// </summary>
        string Description { get; }

        /// <summary>
        /// Gets the FullName of the Type required for any extension to be installed at this extension point.
        /// </summary>
        string TypeName { get; }

        /// <summary>
        /// Gets an enumeration of IExtensionNodes for extensions installed on this extension point.
        /// </summary>
        IEnumerable<IExtensionNode> Extensions { get; }
    }
}


text:
package pw.mario.journal.service.article;

import java.util.List;

import pw.mario.common.exception.PerformActionException;
import pw.mario.common.util.file.FileHandler;
import pw.mario.journal.model.article.Article;
import pw.mario.journal.model.common.Department;
import pw.mario.journal.model.common.Tag;
import pw.mario.journal.model.common.User;
import pw.mario.journal.model.dictionary.Dictionary;

public interface NewArticleService {
	List<User> getUsers(Department d);

	Article createArticle(Article a, FileHandler file) throws PerformActionException;

	List<Dictionary> getArticlesStatuses();

	List<Tag> getTags();

	Article initArticle();

}


text:
<?php

require("server_settings.php");

$frmName = isset($_POST['ut_name']) ? $_POST['ut_name'] : null;
$frmComments = isset($_POST['ut_comments']) ? $_POST['ut_comments'] : null;
$frmScore = isset($_POST['ut_score']) ? $_POST['ut_score'] : null;
$frmLevel = isset($_POST['ut_level']) ? $_POST['ut_level'] : null;
$frmURL = isset($_POST['ut_url']) ? $_POST['ut_url'] : null;
$frmCode = isset($_POST['ut_code']) ? $_POST['ut_code'] : null;

if($frmName && $frmScore > 0){
// Process the new hiscore if one has been passed
	$strSQL =
		'INSERT INTO hiscores ' .
		'(name, comments, url, score, level, code, date) VALUES ' .
		'("' . mysql_real_escape_string($frmName) . '", "' . mysql_real_escape_string($frmComments) . '", ' .
		'"' . mysql_real_escape_string($frmURL) . '", ' . $frmScore . ', ' . $frmLevel . ', "' . mysql_real_escape_string($frmCode) . '", NOW())';

	$db->query($strSQL);

	echo "done=1";
}else{
	echo "error=1";
}

?>


text:
<?php

namespace App\Model;

use Illuminate\Database\Eloquent\Model;

class LessonTag extends Model
{
    //
    protected $guarded = [];
}


text:
struct worldc_st
{
	const struct cparam_st* cparam;
	struct confc_st* confc;

	int sigfd;
	int epfd;
};

extern struct worldc_st* worldc;


text:
This will start up a virtual machine running curatr with some default settings inside a virtual box running the Django server. It should take about 10 minutes depending on the speed of your internet connection.

Dependancies:
1. [Vagrant](vagrantup.com)
2. [Virtualbox](https://www.virtualbox.org/wiki/Downloads)

Steps to get curatr running inside a virtual machine using vagrant.
1. Clone or [download](https://github.com/alexandrovteam/curatr/archive/master.zip) the curatr repository
2. Find this directory `cd ./curatr/vagrant`
3. Edit setup.sh and change the password on line 17 (optionally also change the username)
4. Run `vagrant up`

Curatr should now be visible at [localhost:8080/](http://localhost:8080/).

To change curatr settings:
1. From the vagrant folder: `vagrant ssh`
2. `nano mcf_standard_browser/mcf_standard_browser/settings.py`

To check curatr status / errors
1. `vagrant ssh`
2. `screen -r curatr`

To check celery status / errors
1. `vagrant ssh`
2. `screen -r celery`


text:
<?php

namespace TreeHouse\SwiftBundle\Metadata;

use TreeHouse\KeystoneBundle\Model\Service;

interface DriverFactoryInterface
{
    /**
     * @param Service $service
     *
     * @return DriverInterface
     */
    public function getDriver(Service $service);
}


text:
package com.nibado.bing.enums;

public enum TimeType {
    ARRIVAL("Arrival"),
    DEPARTURE("Departure"),
    LAST_AVAILABLE("LastAvailable");

    private String value;

    TimeType(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value;
    }
}


text:
require_relative 'entity'

module Restconomic
  class Customers < Entity
  end
end


text:
<?php

// Simple test console
set_time_limit(0);

require_once __DIR__ . '/autoload.php';

use Symfony\Bundle\FrameworkBundle\Console\Application;

$kernel = new AppKernel('dev', true);
$application = new Application($kernel);
$application->run();


text:
This script is a wrapper for Cortex XDR and CrowdStrike to remove files in given path.

## Script Data
---

| **Name** | **Description** |
| --- | --- |
| Script Type | python3 |
| Tags | basescript |
| Cortex XSOAR Version | 6.0.0 |

## Inputs
---

| **Argument Name** | **Description** |
| --- | --- |
| device_ids | List of device IDs. |
| file_path | The file path of the file. |

## Outputs
---

| **Path** | **Description** | **Type** |
| --- | --- | --- |
| PaloAltoNetworksXDR.ScriptRun.action_id | The ID of the initiated action. | Number |
| PaloAltoNetworksXDR.ScriptRun.endpoints_count | The number of endpoints the action was initiated on. | Number |
| CrowdStrike.Command.rm.HostID | The host ID. | String |
| CrowdStrike.Command.rm.Error | The error message raised if the command failed. | String |

## Script Examples
### Example command
```!RemoveFileWrapper device_ids=0bde2c4645294245aca522971ccc44c4 file_path=/tmp/a.txt```

### Context Example
```json
{
    "CrowdStrike": {
        "Command": {
            "rm": {
                "HostID": "0bde2c4645294245aca522971ccc44c4",
                "Error": "Success"
            }
        }
    }
}
```

### Human Readable Output

### Results Summary
|Instance|Command|Result|Comment|
|---|---|---|---|
| ***CrowdstrikeFalcon***: CrowdstrikeFalcon_instance_1 | ***command***: cs-falcon-rtr-remove-file
**args**:
	***host_ids***: 0bde2c4645294245aca522971ccc44c4
	***file_path***: /tmp/a.txt
	***os***: Linux | Success |  |
| ***Cortex XDR - IR***: Cortex XDR - IR_instance_1 | ***command***: xdr-run-script-delete-file
**args**:
	***endpoint_ids***: 0bde2c4645294245aca522971ccc44c4
	***file_path***: /tmp/a.txt | Error | Error in API call [<XX_REPLACED>00] - Internal Server Error
{"reply": {"err_code": <XX_REPLACED>00, "err_msg": "An error occurred while processing XDR public API - No endpoint was found for creating the requested action", "err_extra": "can't create group action id for SCRIPT_EXECUTION"}} |
| ***Cortex XDR - IR***: Cortex XDR - IR_instance_1_copy | ***command***: xdr-run-script-delete-file
**args**:
	***endpoint_ids***: 0bde2c4645294245aca522971ccc44c4
	***file_path***: /tmp/a.txt | Error | Error in API call [<XX_REPLACED>00] - Internal Server Error
{"reply": {"err_code": <XX_REPLACED>00, "err_msg": "An error occurred while processing XDR public API - No endpoint was found for creating the requested action", "err_extra": "can't create group action id for SCRIPT_EXECUTION"}} |

### CrowdStrike Falcon rm over the file: /tmp/a.txt
|HostID|Error|
|---|---|
| 0bde2c4645294245aca522971ccc44c4 | Success |


text:
module Tagging
  def self.denylisted_document_types
    @denylisted_document_types ||=
      YAML.load_file(
        Rails.root.join("config/document_types_excluded_from_the_topic_taxonomy.yml"),
      )["document_types"]
  end
end


text:
interface StripJsonOptions {
    whitespace?: boolean;
}

declare function stripJsonComments(input: string, opts?: StripJsonOptions): string;
export = stripJsonComments;


text:
<!DOCTYPE html>

    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="">
    <meta name="author" content="">

    <title>App 2.0</title>

    <link href="bower_components/bootstrap/dist/css/bootstrap.min.css" rel="stylesheet">

    <link href="assets/css/timeline.css" rel="stylesheet">

    <link href="bower_components/morrisjs/morris.css" rel="stylesheet">

    <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css">

    <link rel="styleSheet" href="bower_components/angular-ui-grid/ui-grid.css"/>

    <link rel="styleSheet" href="bower_components/angular-loading-bar/src/loading-bar.css"/>

    <link rel="styleSheet" href="bower_components/angular-ui-tree/dist/angular-ui-tree.min.css"/>

    <link href="assets/css/clientStyles.min.css" rel="stylesheet">

    <link href="assets/css/sb-admin-2.css" rel="stylesheet">

            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                Toggle navigation

            </button>
              App 2.0

                                John Smith

                                        Yesterday

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend.

                                John Smith

                                        Yesterday

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend.

                                John Smith

                                        Yesterday

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque eleifend.

                            Read All Messages

                                    Task 1
                                    40% Complete

                                        40% Complete (success)

                                    Task 2
                                    20% Complete

                                        20% Complete

                                    Task 3
                                    60% Complete

                                        60% Complete (warning)

                                    Task 4
                                    80% Complete

                                        80% Complete (danger)

                            See All Tasks

                                 New Comment
                                4 minutes ago

                                 3 New Followers
                                12 minutes ago

                                 Message Sent
                                4 minutes ago

                                 New Task
                                4 minutes ago

                                 Server Rebooted
                                4 minutes ago

                            See All Alerts

 User Profile

 Settings

 Logout

                            <input type="text" class="form-control" placeholder="Search.">

                                <button class="btn btn-default" type="button">

                                </button>

                        Home

                        SMB RTPA

                        FAST

                        Consumer RTPA


text:
using MSyics.Traceyi.Layout;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Xunit;
using Xunit.Abstractions;

namespace MSyics.Traceyi.Tests.Layout
{
    public class LogLayoutConverterTests
    {
        readonly ITestOutputHelper testOutput;

        public LogLayoutConverterTests(ITestOutputHelper testOutput)
        {
            this.testOutput = testOutput;
        }

        /****************************************************************
         * Convert
         ****************************************************************/
        #region Convert
        [Theory]
        [MemberData(nameof(Convert_ReturnsDefault_Data))]
        public void Convert_ReturnsDefault(string format, string expected)
        {
            // Arrange
            var converter = new LogLayoutConverter(
                new LogLayoutPart { Name = "tab", CanFormat = false },
                new LogLayoutPart { Name = "newLine", CanFormat = false },
                new LogLayoutPart { Name = "action", CanFormat = true },
                new LogLayoutPart { Name = "traced", CanFormat = true },
                new LogLayoutPart { Name = "elapsed", CanFormat = true },
                new LogLayoutPart { Name = "activityId", CanFormat = true },
                new LogLayoutPart { Name = "scopeLabel", CanFormat = true },
                new LogLayoutPart { Name = "scopeId", CanFormat = true },
                new LogLayoutPart { Name = "scopeParentId", CanFormat = true },
                new LogLayoutPart { Name = "scopeDepth", CanFormat = true },
                new LogLayoutPart { Name = "threadId", CanFormat = true },
                new LogLayoutPart { Name = "processId", CanFormat = true },
                new LogLayoutPart { Name = "processName", CanFormat = true },
                new LogLayoutPart { Name = "machineName", CanFormat = true },
                new LogLayoutPart { Name = "message", CanFormat = true },
                new LogLayoutPart { Name = "extensions", CanFormat = true },
                new LogLayoutPart { Name = "@", CanFormat = true });

            // Act
            var actual = converter.Convert(format);
            testOutput.WriteLine(actual);

            // Assert
            Assert.Equal(expected, actual);
        }

        static IEnumerable<object[]> Convert_ReturnsDefault_Data()
        {
            yield return new object[] { LogLayout.DefaultFormat, @"{2}{0}{3:yyyy-MM-ddTHH:mm:ss.fffffffzzz}{0}{4:d\.hh\:mm\:ss\.fffffff}{0}{7:|-,16:R}{0}{8:|-,16:R}{0}{9}{0}{6}{0}{5}{0}{10}{0}{11}{0}{12}{0}{13}{0}{14}{0}{15:=>json}" };
            yield return new object[] { "", @"" };
            yield return new object[] { "{0}", @"{{0}}" };
            yield return new object[] { "{0", @"{{0" };
            yield return new object[] { "0}", @"0}}" };
            yield return new object[] { "{tab}", "{0}" };
            yield return new object[] { "{@}", "{16}" };
            yield return new object[] { "{tab|_,4:R}", "{0}" };
        }

        [Theory]
        [MemberData(nameof(Convert_CanFormat_Data))]
        public void Convert_CanFormat(string format, string expected)
        {
            // Arrange
            var converter = new LogLayoutConverter(
                new LogLayoutPart { Name = "can_not_foramt", CanFormat = false },
                new LogLayoutPart { Name = "can_foramt", CanFormat = true });

            // Act
            var actual = converter.Convert(format);
            testOutput.WriteLine(actual);

            // Assert
            Assert.Equal(expected, actual);
        }

        static IEnumerable<object[]> Convert_CanFormat_Data()
        {
            yield return new object[] { "{can_not_foramt|_,4:R}", "{0}" };
            yield return new object[] { "{can_foramt|_,0:R}", "{1:|_,0:R}" };
            yield return new object[] { "{can_foramt=>json}", "{1:=>json}" };
        }
        #endregion

        /****************************************************************
         * IsPartPlaced
         ****************************************************************/
        #region IsPartPlaced
        [Theory]
        [MemberData(nameof(IsPartPlaced_ReturnsTrue_Data))]
        public void IsPartPlaced_ReturnsTrue(string name, string placed, bool expected)
        {
            // Arrange
            var converter = new LogLayoutConverter(new LogLayoutPart { Name = name, CanFormat = true });
            converter.Convert($"{{{name}}}");

            // Act
            var actual = converter.IsPartPlaced(placed);

            // Assert
            Assert.Equal(expected, actual);
        }

        static IEnumerable<object[]> IsPartPlaced_ReturnsTrue_Data()
        {
            yield return new object[] { "hoge", "hoge", true };
            yield return new object[] { "hoge", "piyo", false };
        }
        #endregion
    }
}


text:
#include <malloc.h>
#include <string.h>
#include "lrsll.h"

void lrsll_freeList(lrsll_list *list)
{
	if (!list)
		return;

	lrsll_node *currentNode = list->head;
	while (currentNode != NULL) {
		lrsll_node *delete = currentNode;
		currentNode = currentNode->next;
		lrsll_freeNode(delete);
	}
	free(list);
}

void lrsll_freeNode(lrsll_node *node)
{
	if (!node)
		return;
	if (node->data)
		free(node->data);
	free(node);
}

void lrsll_printList(lrsll_list *list, FILE *stream)
{
	if (!stream)
		stream = stdout;
	lrsll_node *temp = list->head;
	fprintf(stream, "\nCurrent list - \n");
	while (temp && temp->data) {
		fprintf(stream, "\t%s", temp->data);
		temp = temp->next;
	}
	fprintf(stream, "%s", (list->head == temp) ? "\tEmpty\n" : "\n");
}

lrsll_list *lrsll_createList()
{
	lrsll_list *list = malloc(sizeof(lrsll_list));
	list->head = NULL;
	list->tail = NULL;
	return list;
}

//TODO investigate overloading in C - variadic macro?
lrsll_node *lrsll_createNode(char *data, lrsll_node *next)
{
	if (data == NULL || strlen(data) < 0)
		return NULL;
	lrsll_node *node = malloc(sizeof(lrsll_node));
	node->data = strdup(data);
	node->next = next;
	return node;
}

lrsll_node *lrsll_push(lrsll_list *list, char *data)
{
	lrsll_node *node = lrsll_createNode(data, list->head);
	if (!node)
		return NULL;

	list->head = node;
	if (list->tail == NULL)
		list->tail = node;
	return node;
};

lrsll_node *lrsll_append(lrsll_list *list, char *data)
{

	lrsll_node *node = lrsll_createNode(data, NULL);
	if (list->tail) {
		list->tail->next = node;
		list->tail = node;
	} else {
		list->tail = node;
		list->head = node;
	}

	return node;
};

lrsll_node *lrsll_top(lrsll_list *list)
{
	if (!lrsll_isEmpty(list))
		return list->head;
	return NULL;
};

lrsll_node *lrsll_tail(lrsll_list *list)
{
	if (list != NULL)
		return list->tail;
	return NULL;
};

char *lrsll_popFront(lrsll_list *list)
{
	if (lrsll_isEmpty(list))
		return NULL;

	lrsll_node *oldHead = list->head;
	list->head = oldHead->next;
	if (list->head == NULL)
		list->tail = NULL;

	char *string = strdup(oldHead->data);
	lrsll_freeNode(oldHead);
	return string;
};

char *lrsll_popBack(lrsll_list *list)
{
	if (lrsll_isEmpty(list))
		return NULL;

	lrsll_node *oldTail = list->tail;
	char *string = strdup(oldTail->data);

	lrsll_node **newTail = &list->head;
	while (oldTail != *newTail && oldTail != (*newTail)->next) {
		newTail = &(*newTail)->next;
	}
	if (oldTail == *newTail) {
		list->tail = NULL;
		list->head = NULL;
	} else {
		list->tail = *newTail;
		list->tail->next = NULL;
	}

	lrsll_freeNode(oldTail);
	return string;
};

lrsll_node *lrsll_find(lrsll_list *list, char *data)
{
	if (lrsll_isEmpty(list))
		return NULL;
	lrsll_node *n = list->head;
	while (n && strcmp(n->data, data) != 0) {
		n = n->next;
	}
	return n;
};

//!WARNING! convoluted approach for the sake of learning, don't do what Donny Don't does!
lrsll_node *lrsll_delete(lrsll_list *list, char *data)
{
	lrsll_node **node = &list->head;
	while (*node && strcmp((*node)->data, data) != 0) {
		node = &(*node)->next;
	}
	if (*node == NULL)
		return NULL;
	lrsll_node *deleted = *node;
	*node = deleted->next;

	if (deleted == list->tail) {
		/* if node is pointing to head we haven't moved meaning 1 element list so set tail to null Otherwise set tail to
		 * the address of the struct (lrsll_node) that node is currently on plus the offset of the next variable in the struct.
		 * This would work without the offset because next is the first element declared in the struct so the address
		 * of the current node is the same as the address of node.next since the pointer for node.next starts there,
		 * we just need to cast it to an lrsll_node pointer.
		 *
		 * Using offsetof means that if the struct changes so next is not the first item then the program won't break
		 *
		 * Credit to Austin Hastings on SE -
		 * https://codereview.stackexchange.com/questions/175398/delete-node-from-singly-linked-list-with-tail-pointer-in-c
		 * */
		list->tail = (node == &list->head) ? NULL : (lrsll_node *) ((char *) node - offsetof(lrsll_node, next));
		/* Here we cast node to a char pointer which has a size of 1 byte. When you add or subtract you are adding or
		 * subtracting the pointer length. Without this cast if offsetof were 8 for next you would actually subtract 128
		 * bytes from the address as sizeof(lrsll_node) is 16. So we subtract offsetof bytes from where we currently are
		 * which brings us to the address of the struct containing the next pointer which brought us to deleted node. i.e
		 * the new tail
		 * */
	}

	return deleted;
};

bool lrsll_isEmpty(lrsll_list *list)
{
	return list == NULL || list->head == NULL;
};

lrsll_node *lrsll_addBefore(lrsll_list *list, char *item, char *data)
{
	lrsll_node **node = &list->head;
	while (*node && strcmp((*node)->data, item) != 0) {
		node = &(*node)->next;
	}

	if (*node == NULL)
		return *node;

	lrsll_node *newNode = lrsll_createNode(data, *node);
	*node = newNode;
	return newNode;

};

lrsll_node *lrsll_addAfter(lrsll_list *list, char *item, char *data)
{
	lrsll_node **node = &list->head;
	while (*node && strcmp((*node)->data, item) != 0) {
		node = &(*node)->next;
	}

	if (*node == NULL)
		return *node;

	lrsll_node *newNode = lrsll_createNode(data, (*node)->next);
	(*node)->next = newNode;
	if (newNode->next == NULL)
		list->tail = newNode;
	return newNode;
};


text:
var five = require("johnny-five"),
    board, potentiometer;

board = new five.Board();

board.on("ready", function() {

  // Create a new `potentiometer` hardware instance.
  potentiometer = new five.Sensor({
    pin: "A2",
    freq: 250
  });

  // Inject the `sensor` hardware into
  // the Repl instance's context;
  // allows direct command line access
  board.repl.inject({
    pot: potentiometer
  });

  // "data" get the current reading from the potentiometer
  potentiometer.on("data", function() {
    console.log( this.value, this.raw );
  });
});

// References
//
// http://arduino.cc/en/Tutorial/AnalogInput


text:
su -c "/usr/lib/postgresql/9.2/bin/psql -U postgres -d mirthdb < /docker-entrypoint-initdb.d/mirthdb.sql" postgres

# then start mirth as "root"
cp /usr/local/mirth/conf/mirth.properties /usr/local/mirth/conf/mirth.properties.ori
###cp /usr/local/mirth/conf/mirth.properties.new /usr/local/mirth/conf/mirth.properties

service mcservice start


text:
START_ATF_NAMESPACE
    namespace Detail
    {

        Info::_attack_siege_result_zoclctor__attack_siege_result_zocl2_ptr _attack_siege_result_zoclctor__attack_siege_result_zocl2_next(nullptr);
        Info::_attack_siege_result_zoclctor__attack_siege_result_zocl2_clbk _attack_siege_result_zoclctor__attack_siege_result_zocl2_user(nullptr);

        Info::_attack_siege_result_zoclsize4_ptr _attack_siege_result_zoclsize4_next(nullptr);
        Info::_attack_siege_result_zoclsize4_clbk _attack_siege_result_zoclsize4_user(nullptr);

        void _attack_siege_result_zoclctor__attack_siege_result_zocl2_wrapper(struct _attack_siege_result_zocl* _this)
        {
           _attack_siege_result_zoclctor__attack_siege_result_zocl2_user(_this, _attack_siege_result_zoclctor__attack_siege_result_zocl2_next);
        };
        int _attack_siege_result_zoclsize4_wrapper(struct _attack_siege_result_zocl* _this)
        {
           return _attack_siege_result_zoclsize4_user(_this, _attack_siege_result_zoclsize4_next);
        };

        ::std::array<hook_record, 2> _attack_siege_result_zocl_functions =
        {
            _hook_record {
                (LPVOID)0x1400eefd0L,
                (LPVOID *)&_attack_siege_result_zoclctor__attack_siege_result_zocl2_user,
                (LPVOID *)&_attack_siege_result_zoclctor__attack_siege_result_zocl2_next,
                (LPVOID)cast_pointer_function(_attack_siege_result_zoclctor__attack_siege_result_zocl2_wrapper),
                (LPVOID)cast_pointer_function((void(_attack_siege_result_zocl::*)())&_attack_siege_result_zocl::ctor__attack_siege_result_zocl)
            },
            _hook_record {
                (LPVOID)0x1400eeff0L,
                (LPVOID *)&_attack_siege_result_zoclsize4_user,
                (LPVOID *)&_attack_siege_result_zoclsize4_next,
                (LPVOID)cast_pointer_function(_attack_siege_result_zoclsize4_wrapper),
                (LPVOID)cast_pointer_function((int(_attack_siege_result_zocl::*)())&_attack_siege_result_zocl::size)
            },
        };
    }; // end namespace Detail
END_ATF_NAMESPACE


text:
<?php

namespace Test2;

use BlueDB\Entity\StrongEntity;
use BlueDB\Entity\FieldTypeEnum;
use BlueDB\Entity\PropertyTypeEnum;

class Car extends StrongEntity
{
	public static function getTableName() { return "Car"; }

	/**
	 * @var string
	 */
	public $Brand;
	const BrandField="Brand";
	const BrandFieldType=FieldTypeEnum::PROPERTY;
	const BrandColumn=self::BrandField;
	const BrandPropertyType=PropertyTypeEnum::TEXT;
	/**
	 * @var User
	 */
	public $Owner;
	const OwnerField="Owner";
	const OwnerFieldType=FieldTypeEnum::MANY_TO_ONE;
	const OwnerColumn="Owner_ID";
	const OwnerClass=User::class;
}


text:
set(CORE_H_LIST
)

set(CORE_SRC_LIST
	core/Engine.test.cpp
	core/Object.test.cpp
	core/Observer.test.cpp
	core/Timer.test.cpp
)

if(MSVC)
	source_group("Header Files\\core" FILES ${CORE_H_LIST})
	source_group("Source Files\\core" FILES ${CORE_SRC_LIST})
endif()


text:
package com.github.rinde.logistics.pdptw.solver.optaplanner;

import static com.google.common.truth.Truth.assertThat;

import org.junit.Test;

import com.github.rinde.logistics.pdptw.solver.CheapestInsertionHeuristic;
import com.github.rinde.rinsim.central.GlobalStateObject;
import com.github.rinde.rinsim.central.GlobalStateObjectBuilder;
import com.github.rinde.rinsim.central.Solver;
import com.github.rinde.rinsim.core.model.pdp.Parcel;
import com.github.rinde.rinsim.geom.Point;
import com.github.rinde.rinsim.pdptw.common.ObjectiveFunction;
import com.github.rinde.rinsim.scenario.gendreau06.Gendreau06ObjectiveFunction;
import com.google.common.collect.ImmutableList;

/**
 *
 * @author Rinde van Lon
 */
public class CheapestInsertionComparison {

  static final ObjectiveFunction OBJ_FUNC =
    Gendreau06ObjectiveFunction.instance(50d);

  static final Solver OP_CIH = OptaplannerSolvers.builder()
    .withSolverXmlResource(
      "com/github/rinde/logistics/pdptw/solver/optaplanner/cheapestInsertion.xml")
    .withValidated(true)
    .withObjectiveFunction(OBJ_FUNC)
    .withName("test")
    .buildSolverSupplier()
    .get(123L);

  static final Solver RIN_CIH =
    CheapestInsertionHeuristic.supplier(OBJ_FUNC).get(123L);

  static final Parcel A =
    Parcel.builder(new Point(0, 0), new Point(2, 0)).toString("A").build();
  static final Parcel B =
    Parcel.builder(new Point(0, 1), new Point(2, 1)).toString("B").build();
  static final Parcel C =
    Parcel.builder(new Point(0, 2), new Point(2, 2)).toString("C").build();
  static final Parcel D =
    Parcel.builder(new Point(0, 3), new Point(2, 3)).toString("D").build();
  static final Parcel E =
    Parcel.builder(new Point(0, 4), new Point(2, 4)).toString("E").build();
  static final Parcel F =
    Parcel.builder(new Point(0, 5), new Point(2, 5)).toString("F").build();

  @Test
  public void testSimple() throws InterruptedException {
    final GlobalStateObject gso = GlobalStateObjectBuilder.globalBuilder()
      .addAvailableParcels(A)
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of())
        .build())
      .build();

    final ImmutableList<ImmutableList<Parcel>> opResult =
      OP_CIH.solve(gso);

    final ImmutableList<ImmutableList<Parcel>> rindeResult =
      RIN_CIH.solve(gso);
    assertThat(opResult).isEqualTo(rindeResult);
  }

  @Test
  public void test5() throws InterruptedException {
    final GlobalStateObject gso = GlobalStateObjectBuilder.globalBuilder()
      .addAvailableParcels(A, B, C, D, E)
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of())
        .build())
      .build();

    final ImmutableList<ImmutableList<Parcel>> opResult =
      OP_CIH.solve(gso);

    final ImmutableList<ImmutableList<Parcel>> rindeResult =
      RIN_CIH.solve(gso);
    assertThat(opResult).isEqualTo(rindeResult);
  }

  @Test
  public void test5_2() throws InterruptedException {
    final GlobalStateObject gso = GlobalStateObjectBuilder.globalBuilder()
      .addAvailableParcels(A, B, C, D, E, F)
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of(A, B, A, B))
        .build())
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of(C, C))
        .build())
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of(D, D, E, E))
        .build())
      .addVehicle(GlobalStateObjectBuilder.vehicleBuilder()
        .setLocation(new Point(5, 5))
        .setRoute(ImmutableList.<Parcel>of())
        .build())
      .build();

    final ImmutableList<ImmutableList<Parcel>> opResult =
      OP_CIH.solve(gso);
    final ImmutableList<ImmutableList<Parcel>> rindeResult =
      RIN_CIH.solve(gso);

    assertThat(opResult).isEqualTo(rindeResult);
  }
}