hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
df118effa020a46e4255634ec2ac8ae1a406cf6b | 641 | cpp | C++ | UVa 12554 happy birthday song/sample/12554 - A Special Happy Birthday Song.cpp | tadvi/uva | 0ac0cbdf593879b4fb02a3efc09adbb031cb47d5 | [
"MIT"
] | 1 | 2020-11-24T03:17:21.000Z | 2020-11-24T03:17:21.000Z | UVa 12554 happy birthday song/sample/12554 - A Special Happy Birthday Song.cpp | tadvi/uva | 0ac0cbdf593879b4fb02a3efc09adbb031cb47d5 | [
"MIT"
] | null | null | null | UVa 12554 happy birthday song/sample/12554 - A Special Happy Birthday Song.cpp | tadvi/uva | 0ac0cbdf593879b4fb02a3efc09adbb031cb47d5 | [
"MIT"
] | 1 | 2021-04-11T16:22:31.000Z | 2021-04-11T16:22:31.000Z | #include <stdio.h>
int main() {
char song[][20] = {
"Happy", "birthday", "to", "you", "Happy", "birthday", "to", "you"
, "Happy", "birthday", "to", "Rujia", "Happy", "birthday", "to", "you"
};
char name[101][101];
int n, i, j, flag = 0, end = 0;
scanf("%d", &n);
for(i = 0; i < n; i++) scanf("%s", &name[i]);
i = 0, j = 0;
while(1) {
printf("%s: %s\n", name[i], song[j]);
if(i == n-1)
flag = 1;
if(j == 15 && flag)
break;
i++, j++;
if(i >= n) i = 0;
if(j >= 16) j = 0;
}
return 0;
}
/*
3
Mom
Dad
Girlfriend
*/
| 20.677419 | 78 | 0.391576 | tadvi |
df1327b7faf38dbd39b8d241a6ad813749481aa0 | 12,831 | cpp | C++ | Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyFilePathCtrl.cpp | BreakerOfThings/o3de | f4c59f868c726470ec910623facd836047d059c3 | [
"Apache-2.0",
"MIT"
] | null | null | null | Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyFilePathCtrl.cpp | BreakerOfThings/o3de | f4c59f868c726470ec910623facd836047d059c3 | [
"Apache-2.0",
"MIT"
] | null | null | null | Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/PropertyFilePathCtrl.cpp | BreakerOfThings/o3de | f4c59f868c726470ec910623facd836047d059c3 | [
"Apache-2.0",
"MIT"
] | null | null | null | /*
* Copyright (c) Contributors to the Open 3D Engine Project.
* For complete copyright and license terms please see the LICENSE at the root of this distribution.
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*
*/
#include "PropertyFilePathCtrl.h"
AZ_PUSH_DISABLE_WARNING(4244 4251, "-Wunknown-warning-option")
#include <QFileDialog>
#include <QHBoxLayout>
#include <QLineEdit>
#include <QMessageBox>
#include <QToolButton>
AZ_POP_DISABLE_WARNING
#include <AzCore/Utils/Utils.h>
#include <AzQtComponents/Components/Widgets/BrowseEdit.h>
#include <AzQtComponents/Components/Widgets/FileDialog.h>
#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
#include <AzToolsFramework/UI/UICore/WidgetHelpers.h>
namespace AzToolsFramework
{
PropertyFilePathCtrl::PropertyFilePathCtrl(QWidget* parent)
: QWidget(parent)
{
QHBoxLayout* layout = new QHBoxLayout(this);
m_browseEdit = new AzQtComponents::BrowseEdit(this);
m_browseEdit->lineEdit()->setFocusPolicy(Qt::StrongFocus);
m_browseEdit->setLineEditReadOnly(true);
m_browseEdit->setClearButtonEnabled(true);
m_browseEdit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
QObject::connect(
m_browseEdit, &AzQtComponents::BrowseEdit::attachedButtonTriggered, this, &PropertyFilePathCtrl::OnOpenButtonClicked);
// Whenever the browse edit has text, the clear button will be automatically shown
// since we enabled it with setClearButtonEnabled.
// When it is pressed, it clears the browse edit text for us, but we need to do
// some extra logic as well to clear our internal state and trigger our value changed.
QToolButton* clearButton = AzQtComponents::LineEdit::getClearButton(m_browseEdit->lineEdit());
AZ_Assert(clearButton, "Clear button missing from BrowseEdit");
QObject::connect(clearButton, &QToolButton::clicked, this, &PropertyFilePathCtrl::OnClearButtonClicked);
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_browseEdit);
setLayout(layout);
setFocusProxy(m_browseEdit->lineEdit());
setFocusPolicy(m_browseEdit->lineEdit()->focusPolicy());
};
void PropertyFilePathCtrl::SetFilePath(const AZ::IO::Path& filePath)
{
m_currentFilePath = filePath;
m_browseEdit->setText(filePath.c_str());
Q_EMIT FilePathChanged();
}
const AZ::IO::Path& PropertyFilePathCtrl::GetFilePath() const
{
return m_currentFilePath;
}
void PropertyFilePathCtrl::SetFilter(const QString& filter)
{
m_filter = filter;
}
void PropertyFilePathCtrl::SetProductExtension(AZStd::string extension)
{
m_productExtension = AZStd::move(extension);
}
void PropertyFilePathCtrl::SetDefaultFileName(AZ::IO::Path fileName)
{
m_defaultFileName = AZStd::move(fileName);
}
void PropertyFilePathCtrl::OnOpenButtonClicked()
{
// Retrieve what the pre-selected file path should be for the file dialog
QString preselectedFilePath = GetPreselectedFilePath();
// Popup a native file dialog to choose a new or existing file
// Using the AzQtComponents::FileDialog::GetSaveFileName helper will protect the user from entering
// a filename with invalid characters for the AP
QString newFilePath =
AzQtComponents::FileDialog::GetSaveFileName(this, QObject::tr("Open/Save File"), preselectedFilePath, m_filter);
// Try to set the new file path (if one was selected)
// This will handle file paths outside of the safe asset folders
HandleNewFilePathSelected(newFilePath);
}
QString PropertyFilePathCtrl::GetPreselectedFilePath() const
{
QString preselectedFilePath;
// If we don't have any output file set yet, then generate a default
// option for the user
if (m_currentFilePath.empty())
{
AZ::IO::FixedMaxPath defaultPath = AZ::Utils::GetProjectPath();
// If a default filename has been specified, append it to
// the project path to be the default path
if (!m_defaultFileName.empty())
{
defaultPath /= m_defaultFileName;
}
preselectedFilePath = QString::fromUtf8(defaultPath.c_str(), static_cast<int>(defaultPath.Native().size()));
}
// Otherwise, we need to find the proper absolute path based on the relative path
// that is stored
else
{
// The GetFullSourcePathFromRelativeProductPath API only works on product paths,
// so we need to append the product extension to try and find it
AZStd::string relativePath = m_currentFilePath.Native() + m_productExtension;
AZStd::string fullPath;
bool fullPathIsValid = false;
AssetSystemRequestBus::BroadcastResult(
fullPathIsValid, &AssetSystemRequestBus::Events::GetFullSourcePathFromRelativeProductPath, relativePath, fullPath);
// The full source path asset exists on disk, so use that as
// the pre-selected file when the user opens the file picker dialog
if (fullPathIsValid)
{
preselectedFilePath = QString::fromUtf8(fullPath.c_str(), static_cast<int>(fullPath.size()));
}
// GetFullSourcePathFromRelativeProductPath failed so the file doesn't exist on disk yet
// So we need to find it by searching in the asset safe folders
else
{
bool assetSafeFoldersRetrieved = false;
AZStd::vector<AZStd::string> assetSafeFolders;
AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
assetSafeFoldersRetrieved, &AzToolsFramework::AssetSystemRequestBus::Events::GetAssetSafeFolders, assetSafeFolders);
if (!assetSafeFoldersRetrieved)
{
AZ_Error("PropertyFilePathCtrl", false, "Could not acquire a list of asset safe folders from the database.");
return QString();
}
// Find an asset safe folder that already has the existing parent-path that
// would satisfy the relative path currently stored.
//
// Example: m_currentFilePath has a value of "my/sub/folder/image.png"
// It will keep looking until it finds an asset safe folder that has
// a matching sub-directory structure that exists:
// <ASSET_SAFE_FOLDER>/my/sub/folder
for (AZ::IO::Path candidateFilePath : assetSafeFolders)
{
candidateFilePath /= m_currentFilePath;
if (AZ::IO::FixedMaxPath parentCandidatePath = candidateFilePath.ParentPath();
AZ::IO::SystemFile::IsDirectory(parentCandidatePath.c_str()))
{
preselectedFilePath =
QString::fromUtf8(candidateFilePath.c_str(), static_cast<int>(candidateFilePath.Native().size()));
break;
}
}
}
}
return preselectedFilePath;
}
void PropertyFilePathCtrl::HandleNewFilePathSelected(const QString& newFilePath)
{
// If the newFilePath is empty, then the dialog was cancelled,
// so don't process any further.
if (newFilePath.isEmpty())
{
return;
}
// Generate a relative path given the absolute path that was picked.
// If the absolute path wasn't inside an asset safe folder, then
// the call to GenerateRelativeSourcePath will fail.
AZStd::string absolutePath(newFilePath.toUtf8().constData());
AZStd::string relativePath, rootFilePath;
bool relativePathIsValid = false;
AssetSystemRequestBus::BroadcastResult(
relativePathIsValid, &AssetSystemRequestBus::Events::GenerateRelativeSourcePath, absolutePath, relativePath, rootFilePath);
// We have a valid relative path, so update our entry.
if (relativePathIsValid)
{
SetFilePath(relativePath);
}
// The user chose a path outside of an asset safe folder,
// so give them a warning dialog explaining why it can't be saved there
else
{
constexpr const char* errorMessage =
"You can only save assets to either your game project folder or the Gems folder. Update the location and try "
"again.\n\n"
"You can also review and update your save locations in the Registry/AssetProcessorPlatformConfig.setreg file or your Gem's "
"Registry/assetprocessor_settings.setreg file.";
AZ_Error("PropertyFilePathCtrl", false, errorMessage);
QMessageBox* errorDialog = new QMessageBox(GetActiveWindow());
errorDialog->setIcon(QMessageBox::Icon::Warning);
errorDialog->setTextFormat(Qt::RichText);
errorDialog->setWindowTitle(QObject::tr("Invalid save location"));
errorDialog->setText(QObject::tr(errorMessage));
errorDialog->setStandardButtons(QMessageBox::Cancel | QMessageBox::Retry);
errorDialog->setDefaultButton(QMessageBox::Retry);
QObject::connect(
errorDialog, &QDialog::finished,
[this, errorDialog](int resultCode)
{
// If the user wants to retry, re-open the file dialog
// It will automatically be re-opened relative to the default
// asset safe folder (typically the project root)
if (resultCode == QMessageBox::Retry)
{
OnOpenButtonClicked();
}
// Make sure our error dialog gets deleted after it is dismissed.
errorDialog->deleteLater();
});
errorDialog->open();
}
}
void PropertyFilePathCtrl::OnClearButtonClicked()
{
m_currentFilePath.clear();
m_browseEdit->lineEdit()->clearFocus();
Q_EMIT FilePathChanged();
}
void PropertyFilePathHandler::ConsumeAttribute(
PropertyFilePathCtrl* GUI, AZ::u32 attrib, PropertyAttributeReader* attrValue, [[maybe_unused]] const char* debugName)
{
if (attrib == AZ::Edit::Attributes::SourceAssetFilterPattern)
{
AZStd::string filter;
if (attrValue->Read<AZStd::string>(filter))
{
GUI->SetFilter(filter.c_str());
}
}
else if (attrib == AZ::Edit::Attributes::DefaultAsset)
{
AZStd::string defaultAsset;
if (attrValue->Read<AZStd::string>(defaultAsset))
{
GUI->SetDefaultFileName(defaultAsset);
}
}
}
AZ::u32 PropertyFilePathHandler::GetHandlerName() const
{
return AZ_CRC_CE("FilePath");
}
bool PropertyFilePathHandler::IsDefaultHandler() const
{
return true;
}
QWidget* PropertyFilePathHandler::CreateGUI(QWidget* parent)
{
PropertyFilePathCtrl* newCtrl = aznew PropertyFilePathCtrl(parent);
QObject::connect(
newCtrl, &PropertyFilePathCtrl::FilePathChanged, this,
[newCtrl]()
{
PropertyEditorGUIMessages::Bus::Broadcast(&PropertyEditorGUIMessages::RequestWrite, newCtrl);
PropertyEditorGUIMessages::Bus::Broadcast(&PropertyEditorGUIMessages::Bus::Handler::OnEditingFinished, newCtrl);
});
return newCtrl;
}
void PropertyFilePathHandler::WriteGUIValuesIntoProperty(
[[maybe_unused]] size_t index, PropertyFilePathCtrl* GUI, property_t& instance, [[maybe_unused]] InstanceDataNode* node)
{
AZ::IO::Path filePath = GUI->GetFilePath();
instance = static_cast<property_t>(filePath);
}
bool PropertyFilePathHandler::ReadValuesIntoGUI(
[[maybe_unused]] size_t index, PropertyFilePathCtrl* GUI, const property_t& instance, [[maybe_unused]] InstanceDataNode* node)
{
GUI->blockSignals(true);
GUI->SetFilePath(instance);
GUI->blockSignals(false);
return false;
}
void RegisterFilePathHandler()
{
PropertyTypeRegistrationMessages::Bus::Broadcast(
&PropertyTypeRegistrationMessages::RegisterPropertyType, aznew PropertyFilePathHandler());
}
} // namespace AzToolsFramework
#include "UI/PropertyEditor/moc_PropertyFilePathCtrl.cpp"
| 39.601852 | 140 | 0.636739 | BreakerOfThings |
df18ce567a0c674fe429e126c7cf3560f84d3abd | 9,239 | cpp | C++ | libs/libeventhandler/src/event_handler.cpp | openharmony-sig-ci/appexecfwk_standard | 609acd8632803202bd8af4c2a6bfc99ecf61ea2e | [
"Apache-2.0"
] | 1 | 2021-11-23T08:13:14.000Z | 2021-11-23T08:13:14.000Z | libs/libeventhandler/src/event_handler.cpp | openharmony-sig-ci/appexecfwk_standard | 609acd8632803202bd8af4c2a6bfc99ecf61ea2e | [
"Apache-2.0"
] | null | null | null | libs/libeventhandler/src/event_handler.cpp | openharmony-sig-ci/appexecfwk_standard | 609acd8632803202bd8af4c2a6bfc99ecf61ea2e | [
"Apache-2.0"
] | 1 | 2021-09-13T11:17:54.000Z | 2021-09-13T11:17:54.000Z | /*
* Copyright (c) 2021 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "event_handler.h"
#include "event_handler_utils.h"
#include "thread_local_data.h"
DEFINE_HILOG_LABEL("EventHandler");
namespace OHOS {
namespace AppExecFwk {
static constexpr int DATETIME_STRING_LENGTH = 80;
ThreadLocalData<std::weak_ptr<EventHandler>> EventHandler::currentEventHandler;
std::shared_ptr<EventHandler> EventHandler::Current()
{
const std::weak_ptr<EventHandler> &wp = currentEventHandler;
return wp.lock();
}
EventHandler::EventHandler(const std::shared_ptr<EventRunner> &runner) : eventRunner_(runner)
{}
EventHandler::~EventHandler()
{
if (eventRunner_) {
/*
* This handler is finishing, need to remove all events belong to it.
* But events only have weak pointer of this handler,
* now weak pointer is invalid, so these events become orphans.
*/
eventRunner_->GetEventQueue()->RemoveOrphan();
}
}
bool EventHandler::SendEvent(InnerEvent::Pointer &event, int64_t delayTime, Priority priority)
{
if (!event) {
HILOGE("SendEvent: Could not send an invalid event");
return false;
}
if (!eventRunner_) {
HILOGE("SendEvent: MUST Set event runner before sending events");
return false;
}
InnerEvent::TimePoint now = InnerEvent::Clock::now();
event->SetSendTime(now);
if (delayTime > 0) {
event->SetHandleTime(now + std::chrono::milliseconds(delayTime));
} else {
event->SetHandleTime(now);
}
event->SetOwner(shared_from_this());
eventRunner_->GetEventQueue()->Insert(event, priority);
return true;
}
bool EventHandler::SendTimingEvent(InnerEvent::Pointer &event, int64_t taskTime, Priority priority)
{
InnerEvent::TimePoint nowSys = InnerEvent::Clock::now();
auto epoch = nowSys.time_since_epoch();
long nowSysTime = std::chrono::duration_cast<std::chrono::milliseconds>(epoch).count();
int64_t delayTime = taskTime - nowSysTime;
if (delayTime < 0) {
HILOGE("SendTimingEvent: SendTime is before now systime, change to 0 delaytime Event");
return SendEvent(event, 0, priority);
}
return SendEvent(event, delayTime, priority);
}
bool EventHandler::SendSyncEvent(InnerEvent::Pointer &event, Priority priority)
{
if ((!event) || (priority == Priority::IDLE)) {
HILOGE("SendSyncEvent: Could not send an invalid event or idle event");
return false;
}
if ((!eventRunner_) || (!eventRunner_->IsRunning())) {
HILOGE("SendSyncEvent: MUST Set a running event runner before sending sync events");
return false;
}
// If send a sync event in same event runner, distribute here.
if (eventRunner_ == EventRunner::Current()) {
DistributeEvent(event);
return true;
}
// Create waiter, used to block.
auto waiter = event->CreateWaiter();
// Send this event as normal one.
if (!SendEvent(event, 0, priority)) {
return false;
}
// Wait until event is processed(recycled).
waiter->Wait();
return true;
}
void EventHandler::RemoveAllEvents()
{
if (!eventRunner_) {
HILOGE("RemoveAllEvents: MUST Set event runner before removing all events");
return;
}
eventRunner_->GetEventQueue()->Remove(shared_from_this());
}
void EventHandler::RemoveEvent(uint32_t innerEventId)
{
if (!eventRunner_) {
HILOGE("RemoveEvent: MUST Set event runner before removing events by id");
return;
}
eventRunner_->GetEventQueue()->Remove(shared_from_this(), innerEventId);
}
void EventHandler::RemoveEvent(uint32_t innerEventId, int64_t param)
{
if (!eventRunner_) {
HILOGE("RemoveEvent: MUST Set event runner before removing events by id and param");
return;
}
eventRunner_->GetEventQueue()->Remove(shared_from_this(), innerEventId, param);
}
void EventHandler::RemoveTask(const std::string &name)
{
if (!eventRunner_) {
HILOGE("RemoveTask: MUST Set event runner before removing events by task name");
return;
}
eventRunner_->GetEventQueue()->Remove(shared_from_this(), name);
}
ErrCode EventHandler::AddFileDescriptorListener(
int32_t fileDescriptor, uint32_t events, const std::shared_ptr<FileDescriptorListener> &listener)
{
if ((fileDescriptor < 0) || ((events & FILE_DESCRIPTOR_EVENTS_MASK) == 0) || (!listener)) {
HILOGE("AddFileDescriptorListener(%{public}d, %{public}u, %{public}s): Invalid parameter",
fileDescriptor,
events,
listener ? "valid" : "null");
return EVENT_HANDLER_ERR_INVALID_PARAM;
}
if (!eventRunner_) {
HILOGE("AddFileDescriptorListener: MUST Set event runner before adding fd listener");
return EVENT_HANDLER_ERR_NO_EVENT_RUNNER;
}
listener->SetOwner(shared_from_this());
return eventRunner_->GetEventQueue()->AddFileDescriptorListener(fileDescriptor, events, listener);
}
void EventHandler::RemoveAllFileDescriptorListeners()
{
if (!eventRunner_) {
HILOGE("RemoveAllFileDescriptorListeners: MUST Set event runner before removing all fd listener");
return;
}
eventRunner_->GetEventQueue()->RemoveFileDescriptorListener(shared_from_this());
}
void EventHandler::RemoveFileDescriptorListener(int32_t fileDescriptor)
{
if (fileDescriptor < 0) {
HILOGE("RemoveFileDescriptorListener(%{public}d): Invalid parameter", fileDescriptor);
return;
}
if (!eventRunner_) {
HILOGE("RemoveFileDescriptorListener: MUST Set event runner before removing fd listener by fd");
return;
}
eventRunner_->GetEventQueue()->RemoveFileDescriptorListener(fileDescriptor);
}
void EventHandler::SetEventRunner(const std::shared_ptr<EventRunner> &runner)
{
if (eventRunner_ == runner) {
return;
}
if (eventRunner_) {
HILOGW("SetEventRunner: It is not recommended to change the event runner dynamically");
// Remove all events and listeners from old event runner.
RemoveAllEvents();
RemoveAllFileDescriptorListeners();
}
// Switch event runner.
eventRunner_ = runner;
return;
}
void EventHandler::DistributeEvent(const InnerEvent::Pointer &event)
{
if (!event) {
HILOGE("DistributeEvent: Could not distribute an invalid event");
return;
}
// Save old event handler.
std::weak_ptr<EventHandler> oldHandler = currentEventHandler;
// Save current event handler into thread local data.
currentEventHandler = shared_from_this();
if (event->HasTask()) {
// Call task callback directly if contains a task.
(event->GetTaskCallback())();
} else {
// Otherwise let developers to handle it.
ProcessEvent(event);
}
// Restore current event handler.
if (oldHandler.expired()) {
currentEventHandler = nullptr;
} else {
currentEventHandler = oldHandler;
}
}
void EventHandler::Dump(Dumper &dumper)
{
struct tm curTime = {0};
auto tt = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
localtime_r(&tt, &curTime);
char sysTime[DATETIME_STRING_LENGTH];
std::strftime(sysTime, sizeof(char) * DATETIME_STRING_LENGTH, "%Y%m%d %I:%M %p", &curTime);
std::string message =
dumper.GetTag() + " EventHandler dump begain curTime:" + std::string(sysTime) + LINE_SEPARATOR;
dumper.Dump(message);
if (eventRunner_ == nullptr) {
dumper.Dump(dumper.GetTag() + " event runner uninitialized!" + LINE_SEPARATOR);
} else {
eventRunner_->Dump(dumper);
}
}
bool EventHandler::HasInnerEvent(uint32_t innerEventId)
{
if (!eventRunner_) {
HILOGE("event runner uninitialized!");
return false;
}
return eventRunner_->GetEventQueue()->HasInnerEvent(shared_from_this(), innerEventId);
}
bool EventHandler::HasInnerEvent(int64_t param)
{
if (!eventRunner_) {
HILOGE("event runner uninitialized!");
return false;
}
return eventRunner_->GetEventQueue()->HasInnerEvent(shared_from_this(), param);
}
std::string EventHandler::GetEventName(const InnerEvent::Pointer &event)
{
std::string eventName;
if (!event) {
return eventName;
}
if (event->HasTask()) {
eventName = event->GetTaskName();
} else {
eventName = std::to_string(event->GetInnerEventId());
}
return eventName;
}
bool EventHandler::IsIdle()
{
return eventRunner_->GetEventQueue()->IsIdle();
}
void EventHandler::ProcessEvent(const InnerEvent::Pointer &)
{}
} // namespace AppExecFwk
} // namespace OHOS | 29.707395 | 106 | 0.677887 | openharmony-sig-ci |
df1d90e79a4ed477c6654e89de578a4a0639334b | 59 | cpp | C++ | lecture/src/cpp/MyRecipeNote/File.cpp | mac-novice-pg2/tool_dev | c988b72f803f24a130e08ef8515ec282119e377f | [
"BSD-3-Clause"
] | null | null | null | lecture/src/cpp/MyRecipeNote/File.cpp | mac-novice-pg2/tool_dev | c988b72f803f24a130e08ef8515ec282119e377f | [
"BSD-3-Clause"
] | 1 | 2018-09-28T13:33:18.000Z | 2018-09-28T13:33:18.000Z | lecture/src/cpp/MyRecipeNote/File.cpp | mac-novice-pg2/tool_dev | c988b72f803f24a130e08ef8515ec282119e377f | [
"BSD-3-Clause"
] | null | null | null | #include "File.h"
File::File()
{
}
File::~File()
{
}
| 4.538462 | 18 | 0.474576 | mac-novice-pg2 |
df1db50c0b217aa8de54ab7f295324b96710a4c2 | 2,618 | cpp | C++ | range-v3/test/view/unique.cpp | jiayuehua/parallelts-range-exploration | 53b574f650995d1f113d663d7217511a93145ba0 | [
"Apache-2.0"
] | 11 | 2018-01-12T18:29:59.000Z | 2022-01-22T21:50:56.000Z | test/view/unique.cpp | pacxx/range-v3 | bf7494563ce555494024a038042ee279eefeec7d | [
"MIT"
] | 15 | 2017-12-19T11:10:41.000Z | 2018-02-13T10:46:13.000Z | test/view/unique.cpp | pacxx/range-v3 | bf7494563ce555494024a038042ee279eefeec7d | [
"MIT"
] | 1 | 2021-01-08T13:17:16.000Z | 2021-01-08T13:17:16.000Z | // Range v3 library
//
// Copyright Eric Niebler 2014
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#include <iostream>
#include <cctype>
#include <cstring>
#include <string>
#include <vector>
#include <range/v3/core.hpp>
#include <range/v3/view/unique.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/utility/iterator.hpp>
#include "../simple_test.hpp"
#include "../test_utils.hpp"
#include <range/v3/view/transform.hpp>
using std::toupper;
// from http://stackoverflow.com/a/2886589/195873
struct ci_char_traits : public std::char_traits<char>
{
static bool eq(char c1, char c2) { return toupper(c1) == toupper(c2); }
static bool ne(char c1, char c2) { return toupper(c1) != toupper(c2); }
static bool lt(char c1, char c2) { return toupper(c1) < toupper(c2); }
static int compare(const char* s1, const char* s2, size_t n)
{
for(; n-- != 0; ++s1, ++s2)
{
if(toupper(*s1) < toupper(*s2))
return -1;
if(toupper(*s1) > toupper(*s2))
return 1;
}
return 0;
}
static const char* find(const char* s, int n, char a)
{
for(; n-- > 0; ++s)
if(toupper(*s) != toupper(a))
break;
return s;
}
};
typedef std::basic_string<char, ci_char_traits> ci_string;
int main()
{
using namespace ranges;
int rgi[] = {1, 1, 1, 2, 3, 4, 4};
std::vector<int> out;
auto && rng = rgi | view::unique;
has_type<int &>(*begin(rng));
models<concepts::BoundedView>(rng);
models_not<concepts::SizedView>(rng);
models<concepts::ForwardIterator>(begin(rng));
models_not<concepts::BidirectionalIterator>(begin(rng));
copy(rng, ranges::back_inserter(out));
::check_equal(out, {1, 2, 3, 4});
std::vector<ci_string> rgs{"hello", "HELLO", "bye", "Bye", "BYE"};
auto && rng3 = rgs | view::unique;
has_type<ci_string &>(*begin(rng3));
models<concepts::ForwardView>(rng3);
models<concepts::BoundedView>(rng3);
models_not<concepts::SizedView>(rng3);
models<concepts::ForwardIterator>(begin(rng3));
models_not<concepts::BidirectionalIterator>(begin(rng3));
auto fs = rng3 | view::transform([](ci_string s){return std::string(s.c_str());});
::check_equal(fs, {"hello","bye"});
return test_result();
}
| 29.41573 | 86 | 0.627196 | jiayuehua |
df20d52c0b6d4fbab5b4e45af39b69d01d95de12 | 491 | cpp | C++ | calibration-cli/src/main.cpp | mc18g13/teensy-drone | 21a396c44a32b85d6455de2743e52ba2c95bb07d | [
"MIT"
] | null | null | null | calibration-cli/src/main.cpp | mc18g13/teensy-drone | 21a396c44a32b85d6455de2743e52ba2c95bb07d | [
"MIT"
] | null | null | null | calibration-cli/src/main.cpp | mc18g13/teensy-drone | 21a396c44a32b85d6455de2743e52ba2c95bb07d | [
"MIT"
] | null | null | null | #include <Arduino.h>
#include "MARGCalibrationHandler.h"
#include "ReceiverCalibrationHandler.h"
#include <arm_math.h>
#include "MenuOptionHandler.h"
#include "MainMenuHandler.h"
MARGCalibrationHandler margCalibrationHandler;
ReceiverCalibrationHandler receiverHandler;
MainMenuHandler mainMenu;
void setup() {
mainMenu.addOptionHandler(&margCalibrationHandler);
mainMenu.addOptionHandler(&receiverHandler);
mainMenu.setup();
}
void loop() {
delay(1000);
mainMenu.start();
} | 19.64 | 53 | 0.790224 | mc18g13 |
afff9df32294269c04ac98691aede97da9a36648 | 1,351 | cpp | C++ | brackets_match/test/brackets_match_test.cpp | fanck0605/shit-algorithm | 75031bb25b59e0594a792f909a6f97bb0375120d | [
"MIT"
] | null | null | null | brackets_match/test/brackets_match_test.cpp | fanck0605/shit-algorithm | 75031bb25b59e0594a792f909a6f97bb0375120d | [
"MIT"
] | null | null | null | brackets_match/test/brackets_match_test.cpp | fanck0605/shit-algorithm | 75031bb25b59e0594a792f909a6f97bb0375120d | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
#include <map>
int main()
{
std::string bracketList = "([{}])";
std::map<char, char> bracketPairs{{'{', '}'}, {'[', ']'}, {'(', ')'}};
std::vector<char> leftBracketStack;
for (const auto ch : bracketList)
{
char leftBracket;
char rightBracket;
switch (ch)
{
case '{':
case '[':
case '(':
leftBracketStack.push_back(ch);
break;
case '}':
case ']':
case ')':
if (leftBracketStack.empty())
{
std::cout << "lack left bracket!" << std::endl;
return 0;
}
leftBracket = leftBracketStack.back();
rightBracket = bracketPairs[leftBracket];
if (rightBracket != ch)
{
std::cout << "not match!" << std::endl;
std::cout << "except: " << rightBracket << std::endl;
std::cout << "result: " << ch << std::endl;
return 0;
}
leftBracketStack.pop_back();
break;
default:
break;
}
}
if (!leftBracketStack.empty())
{
std::cout << "lack right bracket!";
return 0;
}
std::cout << "match success!" << std::endl;
return 0;
}
| 23.701754 | 74 | 0.437454 | fanck0605 |
afffb8aa73229fc9aeffa839acdc88d43c206155 | 15,328 | cpp | C++ | master/autotools-book-files/autotools/book/flaim-ch8-10/flaim/util/viewedit.cpp | AlexRogalskiy/DevArtifacts | 931aabb8cbf27656151c54856eb2ea7d1153203a | [
"MIT"
] | 4 | 2018-09-07T15:35:24.000Z | 2019-03-27T09:48:12.000Z | master/autotools-book-files/autotools/book/flaim-ch8-10/flaim/util/viewedit.cpp | AlexRogalskiy/DevArtifacts | 931aabb8cbf27656151c54856eb2ea7d1153203a | [
"MIT"
] | 371 | 2020-03-04T21:51:56.000Z | 2022-03-31T20:59:11.000Z | master/autotools-book-files/autotools/book/flaim-ch8-10/flaim/util/viewedit.cpp | AlexRogalskiy/DevArtifacts | 931aabb8cbf27656151c54856eb2ea7d1153203a | [
"MIT"
] | 3 | 2019-06-18T19:57:17.000Z | 2020-11-06T03:55:08.000Z | //-------------------------------------------------------------------------
// Desc: Editing routines for the database viewer utility.
// Tabs: 3
//
// Copyright (c) 1992-2001, 2003-2007 Novell, Inc. All Rights Reserved.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; version 2.1
// of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com.
//
// $Id$
//------------------------------------------------------------------------------
#include "view.h"
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewGetNum(
const char * Prompt,
void * NumRV,
FLMUINT EnterHexFlag,
FLMUINT NumBytes,
FLMUINT MaxValue,
FLMUINT * ValEntered)
{
char TempBuf[ 20];
FLMUINT i;
FLMUINT c;
FLMINT GetOK;
FLMUINT Num;
FLMUINT MaxDigits;
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
if( EnterHexFlag)
MaxDigits = (NumBytes == 4) ? 8 : ((NumBytes == 2) ? 4 : 2);
else
MaxDigits = (NumBytes == 4) ? 10 : ((NumBytes == 2) ? 5 : 3);
for( ;;)
{
GetOK = TRUE;
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( Prompt, TempBuf, sizeof( TempBuf));
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if( f_stricmp( TempBuf, "\\") == 0)
{
*ValEntered = FALSE;
return( FALSE);
}
if( !TempBuf[ 0])
{
*ValEntered = FALSE;
return( TRUE);
}
i = 0;
Num = 0;
while( (TempBuf[ i]) && (i < MaxDigits))
{
c = TempBuf[ i];
if( EnterHexFlag)
{
Num <<= 4;
if( (c >= '0') && (c <= '9'))
Num += (FLMUINT)(c - '0');
else if( (c >= 'a') && (c <= 'f'))
Num += (FLMUINT)(c - 'a' + 10);
else if( (c >= 'A') && (c <= 'F'))
Num += (FLMUINT)(c - 'A' + 10);
else
{
ViewShowError( "Illegal digit in number - must be hex digits");
GetOK = FALSE;
break;
}
}
else if( (c < '0') || (c > '9'))
{
ViewShowError( "Illegal digit in number - must be 0 through 9");
GetOK = FALSE;
break;
}
else
{
if( MaxValue / 10 < Num)
{
ViewShowError( "Number is too large");
GetOK = FALSE;
break;
}
else
{
Num *= 10;
if( MaxValue - (FLMUINT)(c - '0') < Num)
{
ViewShowError( "Number is too large");
GetOK = FALSE;
break;
}
else
Num += (FLMUINT)(c - '0');
}
}
i++;
}
if( GetOK)
{
if( NumBytes == 4)
*((FLMUINT *)(NumRV)) = Num;
else if( NumBytes == 2)
*((FLMUINT *)(NumRV)) = (FLMUINT)Num;
else
*((FLMBYTE *)(NumRV)) = (FLMBYTE)Num;
*ValEntered = TRUE;
return( TRUE);
}
}
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEditNum(
void * NumRV,
FLMUINT EnterHexFlag,
FLMUINT NumBytes, /* WAS FLMUINT */
FLMUINT MaxValue
)
{
char Prompt[ 80];
FLMUINT ValEntered;
f_strcpy( Prompt, "Enter Value (in ");
if( EnterHexFlag)
f_strcpy( &Prompt[ f_strlen( Prompt)], "hex): ");
else
f_strcpy( &Prompt[ f_strlen( Prompt)], "decimal): ");
if( (!ViewGetNum( Prompt, NumRV, EnterHexFlag, (FLMUINT)NumBytes, MaxValue,
&ValEntered)) ||
(!ValEntered))
return( FALSE);
else
return( TRUE);
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEditText(
const char * Prompt,
char * TextRV,
FLMUINT TextLen,
FLMUINT * ValEntered)
{
char TempBuf[ 100];
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( Prompt, TempBuf, sizeof( TempBuf) - 1);
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if( f_stricmp( TempBuf, "\\") == 0)
{
*ValEntered = FALSE;
return( FALSE);
}
if( !TempBuf[ 0])
{
*ValEntered = FALSE;
return( TRUE);
}
f_memset( TextRV, 0, TextLen);
if( f_strlen( TempBuf) >= TextLen)
f_memcpy( TextRV, TempBuf, TextLen);
else
f_strcpy( TextRV, TempBuf);
*ValEntered = TRUE;
return( TRUE);
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEditLanguage(
FLMUINT * LangRV)
{
char TempBuf[ 80];
FLMUINT TempNum;
FLMUINT ValEntered;
for( ;;)
{
if( (!ViewEditText( "Enter Language Code: ",
TempBuf, 3, &ValEntered)) || (!ValEntered))
return( FALSE);
if( f_strlen( TempBuf) != 2)
{
TempNum = 0;
TempBuf[ 0] = 0;
}
else
{
if( (TempBuf[ 0] >= 'a') && (TempBuf[ 0] <= 'z'))
TempBuf[ 0] = TempBuf[ 0] - 'a' + 'A';
if( (TempBuf[ 1] >= 'a') && (TempBuf[ 1] <= 'z'))
TempBuf[ 1] = TempBuf[ 0] - 'a' + 'A';
TempNum = f_languageToNum( (char *)TempBuf);
}
if( (TempNum == 0) &&
((TempBuf[ 0] != 'U') || (TempBuf[ 1] != 'S')))
ViewShowError( "Illegal language code");
else
{
*LangRV = TempNum;
return( TRUE);
}
}
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEditBinary(
const char * Prompt,
char * Buf,
FLMUINT * ByteCountRV,
FLMUINT * ValEntered)
{
FLMUINT MaxBytes = *ByteCountRV;
FLMUINT ByteCount;
FLMUINT Odd;
char TempBuf[ 300];
FLMUINT i;
char TempPrompt[ 80];
FLMUINT uiNumCols;
FLMUINT uiNumRows;
f_conGetScreenSize( &uiNumCols, &uiNumRows);
if( Prompt == NULL)
{
f_strcpy( TempPrompt, "Enter Binary Values (in hex): ");
Prompt = &TempPrompt[ 0];
}
for( ;;)
{
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
ViewAskInput( Prompt, TempBuf, sizeof( TempBuf));
f_conSetBackFore( FLM_BLACK, FLM_WHITE);
f_conClearScreen( 0, uiNumRows - 2);
if( f_stricmp( TempBuf, "\\") == 0)
{
*ValEntered = FALSE;
return( FALSE);
}
if( !TempBuf[ 0])
{
*ValEntered = FALSE;
return( TRUE);
}
Odd = 0;
ByteCount = 0;
i = 0;
while( TempBuf[ i])
{
FLMBYTE Value;
Value = TempBuf[ i];
if( (Value >= '0') && (Value <= '9'))
Value -= '0';
else if( (Value >= 'a') && (Value <= 'f'))
Value = Value - 'a' + 10;
else if( (Value >= 'A') && (Value <= 'F'))
Value = Value - 'A' + 10;
else if( Value == ' ' || Value == '\t')
{
Odd = 0;
i++;
continue;
}
else
{
ByteCount = 0;
ViewShowError( "Non-HEX digits are illegal");
break;
}
/* If we get here, we have another digit */
if( Odd)
{
Odd = 0;
(*Buf) <<= 4;
(*Buf) |= Value;
}
else
{
if( ByteCount == MaxBytes)
break;
/* Don't increment Buf the first time through */
if( ByteCount)
Buf++;
ByteCount++;
*Buf = Value;
Odd = 1;
}
i++;
}
if( !ByteCount)
{
if( !TempBuf[ i])
ViewShowError( "No HEX digits entered");
}
else if( TempBuf[ i])
ViewShowError( "Too many digits entered");
else
{
*ByteCountRV = ByteCount;
*ValEntered = TRUE;
return( TRUE);
}
}
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEditBits(
FLMBYTE * BitRV,
FLMUINT EnterHexFlag,
FLMBYTE Mask)
{
FLMBYTE ShiftBits = 0;
/* Determine the maximum value that can be entered */
while( !(Mask & 0x01))
{
ShiftBits++;
Mask >>= 1;
}
if( !ViewEditNum( BitRV, EnterHexFlag, 1, (FLMUINT)Mask))
return( FALSE);
if( ShiftBits)
(*BitRV) <<= ShiftBits;
return( TRUE);
}
/********************************************************************
Desc: ?
*********************************************************************/
FLMINT ViewEdit(
FLMUINT WriteEntireBlock,
FLMBOOL bRecalcChecksum
)
{
FLMUINT BytesToWrite;
FLMUINT BytesWritten;
FLMUINT Num;
char TempBuf[ 100];
char * BufPtr = NULL;
RCODE rc;
FLMUINT FileOffset;
FLMUINT FileNumber;
FLMUINT ValEntered;
FLMUINT wBytesRead;
IF_FileHdl * pFileHdl = NULL;
FLMBOOL bEncrypted;
FLMBOOL bIsEncBlock;
FLMBOOL bModEnc = FALSE;
if( (gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_DISABLED)
{
ViewShowError( "Cannot modify this value");
return( FALSE);
}
FileOffset = gv_pViewMenuCurrItem->ModFileOffset;
FileNumber = gv_pViewMenuCurrItem->ModFileNumber;
switch( gv_pViewMenuCurrItem->ModType & 0x0F)
{
case MOD_FLMUINT:
BytesToWrite = 4;
if( !ViewEditNum( &Num,
((gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_HEX), 4,
0xFFFFFFFF))
return( FALSE);
UD2FBA( Num, (FLMBYTE *)TempBuf);
break;
case MOD_FLMUINT16:
BytesToWrite = 2;
if( !ViewEditNum( &Num,
((gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_HEX), 2,
0xFFFF))
return( FALSE);
UW2FBA( Num, (FLMBYTE *)TempBuf);
break;
case MOD_FLMBYTE:
BytesToWrite = 1;
if( !ViewEditNum( &TempBuf[ 0],
((gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_HEX), 1, 0xFF))
return( FALSE);
break;
case MOD_BINARY_ENC:
bModEnc = TRUE;
goto Mod_Binary;
case MOD_BINARY:
Mod_Binary:
BytesToWrite = gv_pViewMenuCurrItem->ModBufLen;
if( HAVE_HORIZ_CUR( gv_pViewMenuCurrItem))
{
FileOffset += gv_pViewMenuCurrItem->HorizCurPos;
BytesToWrite -= gv_pViewMenuCurrItem->HorizCurPos;
}
if( (!ViewEditBinary( NULL, TempBuf, &BytesToWrite, &ValEntered)) ||
(!ValEntered))
return( FALSE);
break;
case MOD_TEXT:
if( (!ViewEditText( "Enter Value: ",
TempBuf, gv_pViewMenuCurrItem->ModBufLen, &ValEntered)) ||
(!ValEntered))
return( FALSE);
BytesToWrite = gv_pViewMenuCurrItem->ModBufLen;
break;
case MOD_LANGUAGE:
if( !ViewEditLanguage( &Num))
return( FALSE);
TempBuf[0] = (FLMBYTE) Num;
BytesToWrite = 1;
break;
case MOD_CHILD_BLK:
if( !ViewEditNum( &Num, TRUE, 4, 0xFFFFFFFF))
return( FALSE);
BytesToWrite = 4;
UD2FBA( Num, (FLMBYTE *)TempBuf);
break;
case MOD_BITS:
if( !ViewEditBits( (FLMBYTE *)&TempBuf[ 0],
((gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_HEX),
(FLMBYTE)gv_pViewMenuCurrItem->ModBufLen))
return( FALSE);
BytesToWrite = 1;
break;
case MOD_KEY_LEN:
if( !ViewEditNum( &Num,
((gv_pViewMenuCurrItem->ModType & 0xF0) == MOD_HEX),
2, 0x000003FF))
return( FALSE);
TempBuf[ 0] = (FLMBYTE)((Num >> 8) & 0x0003) << 4;
TempBuf[ 1] = (FLMBYTE)(Num & 0x00FF);
break;
}
/* Read in the block if necessary */
if( !WriteEntireBlock)
{
BufPtr = &TempBuf[ 0];
}
else
{
FLMUINT BlockOffset;
FLMUINT BlkAddress;
FLMUINT16 ui16BlkChkSum;
FLMBOOL bNeedToEncrypt;
BlockOffset = (FLMUINT)(FileOffset %
(FLMUINT)gv_ViewHdrInfo.FileHdr.uiBlockSize);
BlkAddress = FSBlkAddress( FileNumber,
FileOffset - BlockOffset);
FileOffset = FileOffset - BlockOffset;
if( !ViewBlkRead( BlkAddress, (FLMBYTE **)&BufPtr,
gv_ViewHdrInfo.FileHdr.uiBlockSize,
NULL, &ui16BlkChkSum, &wBytesRead, FALSE,
&bIsEncBlock, bModEnc ? FALSE : TRUE, &bEncrypted))
return( FALSE);
bNeedToEncrypt = FALSE;
if (bEncrypted)
{
flmAssert( bIsEncBlock);
flmAssert( bModEnc);
}
else
{
// bModEnc would only be TRUE if the original read returned
// the data encrypted, but if that is the case, this read should
// also have returned the data encrypted.
flmAssert( !bModEnc);
if (bIsEncBlock)
{
bNeedToEncrypt = TRUE;
}
}
/* Put the data in the appropriate place in the block */
if( (gv_pViewMenuCurrItem->ModType & 0x0F) == MOD_BITS)
{
FLMBYTE Mask = (FLMBYTE)gv_pViewMenuCurrItem->ModBufLen;
/* Unset the bits, then OR in the new bits */
BufPtr[ BlockOffset] &= (~(Mask));
BufPtr[ BlockOffset] |= TempBuf[ 0];
}
else if( (gv_pViewMenuCurrItem->ModType & 0x0F) == MOD_KEY_LEN)
{
/* Unset the high bits of the key length, then OR in the new bits */
BufPtr[ BlockOffset] &= ~(0x30);
BufPtr[ BlockOffset] |= TempBuf[ 0];
/* Set the low bits of the key length. */
BufPtr[ BlockOffset + BBE_KL] = TempBuf[ 1];
}
else
{
f_memcpy( BufPtr + BlockOffset, TempBuf, BytesToWrite);
}
// Re-encrypt the data, if necessary
if (bNeedToEncrypt)
{
#ifndef FLM_USE_NICI
// Should not be possible to get here
flmAssert( 0);
#else
IXD * pIxd;
FLMUINT uiIxNum = FB2UW( (const FLMBYTE *)&BufPtr [BH_LOG_FILE_NUM]);
FLMUINT uiEncLen = getEncryptSize( (FLMBYTE *)BufPtr) - BH_OVHD;
FDB * pDb = (FDB *)gv_hViewDb;
FFILE * pFile = pDb->pFile;
flmAssert( uiEncLen);
flmAssert( !pFile->bInLimitedMode);
// Get the index.
if (RC_OK( fdictGetIndex( pFile->pDictList,
pFile->bInLimitedMode, uiIxNum, NULL,
&pIxd, TRUE)) &&
pIxd && pIxd->uiEncId)
{
F_CCS * pCcs = (F_CCS *)pFile->pDictList->pIttTbl[ pIxd->uiEncId].pvItem;
flmAssert( pCcs);
flmAssert( !(uiEncLen % 16));
// Encrypt the buffer in place.
(void)pCcs->encryptToStore( (FLMBYTE *)&BufPtr [BH_OVHD], uiEncLen,
(FLMBYTE *)&BufPtr [BH_OVHD], &uiEncLen);
}
#endif
}
/* Recalculate the checksum */
if (bRecalcChecksum)
{
if (FB2UW( (FLMBYTE *)&BufPtr [BH_BLK_END]) >
gv_ViewHdrInfo.FileHdr.uiBlockSize)
{
UW2FBA( gv_ViewHdrInfo.FileHdr.uiBlockSize,
(FLMBYTE *)&BufPtr [BH_BLK_END]);
}
BlkCheckSum( (FLMBYTE *)BufPtr,
FALSE, BlkAddress,
gv_ViewHdrInfo.FileHdr.uiBlockSize);
}
else
{
/*
Restore checksum bytes to whatever we read. This is necessary
because ViewBlkRead for version 3.x and greater will alter
the low checksum byte after reading the block. It is not
really necessary to restore the high checksum byte, but we
do anyway for consistency.
*/
BufPtr [BH_CHECKSUM_HIGH] = (FLMBYTE)(ui16BlkChkSum >> 8);
BufPtr [BH_CHECKSUM_LOW] = (FLMBYTE)(ui16BlkChkSum & 0x00FF);
}
BytesToWrite = wBytesRead;
}
if (RC_BAD( rc = gv_pSFileHdl->getFileHdl( FileNumber, TRUE, &pFileHdl)))
{
ViewShowRCError( "getting file handle", rc);
}
// Write the data out to the file
else if( RC_BAD( rc = pFileHdl->write( FileOffset, BytesToWrite,
BufPtr, &BytesWritten)))
{
ViewShowRCError( "updating file", rc);
}
else if( RC_BAD( rc = pFileHdl->flush()))
{
ViewShowRCError( "flushing data to file", rc);
}
// Free any memory used to read in the data block
if( BufPtr != &TempBuf[ 0])
{
f_free( &BufPtr);
}
return( TRUE);
}
| 23.838258 | 80 | 0.572482 | AlexRogalskiy |
b303266b3336153638d043eae723858785b0e98b | 2,066 | cpp | C++ | tools/genrpc/genrpc_template.cpp | tkng/pficommon | 1301e1c9f958656e4bc882ae2db9452e8cffab7e | [
"BSD-3-Clause"
] | 48 | 2017-04-03T18:46:24.000Z | 2022-02-28T01:44:05.000Z | tools/genrpc/genrpc_template.cpp | tkng/pficommon | 1301e1c9f958656e4bc882ae2db9452e8cffab7e | [
"BSD-3-Clause"
] | 44 | 2017-02-21T13:13:52.000Z | 2021-02-06T13:08:31.000Z | tools/genrpc/genrpc_template.cpp | tkng/pficommon | 1301e1c9f958656e4bc882ae2db9452e8cffab7e | [
"BSD-3-Clause"
] | 13 | 2016-12-28T05:04:58.000Z | 2021-10-01T02:17:23.000Z | #include "/usr/local/share/pficommon/gen_php.h"
#include "/usr/local/share/pficommon/gen_hs.h"
#include "/usr/local/share/pficommon/gen_null.h"
#define RPC_PROC_BKUP RPC_PROC
#undef RPC_PROC
#define RPC_PROC REFLECT_RPC_PROC
#define RPC_GEN_BKUP RPC_GEN
#undef RPC_GEN
#define RPC_GEN REFLECT_RPC_GEN
#include "<<<SIGFILE>>>"
#undef RPC_GEN
#define RPC_GEN RPC_GEN_BKUP
#undef RPC_GEN_BKUP
#undef RPC_PROC
#define RPC_PROC RPC_PROC_BKUP
#undef RPC_PROC_BKUP
#include <fstream>
using namespace std;
struct info{
const char *id;
const char *suffix;
void (*f)(vector<reflect_base*> &, const string &);
}infos[]={
{"php", "php", &php_generator::generate},
{"haskell", "hs", &haskell_generator::generate},
{"ocaml", "ml", &null_generator::generate},
{"java", "java", &null_generator::generate},
{"ruby", "rb", &null_generator::generate},
{"python", "py", &null_generator::generate},
{"perl", "pl", &null_generator::generate},
};
int main()
{
string base("<<<BASENAME>>>");
string lang("<<<LANG>>>");
size_t lang_num=sizeof(infos)/sizeof(infos[0]);
for (size_t i=0;i<lang_num;i++){
if (infos[i].id==lang){
string outname(base);
string new_suf("."+string(infos[i].suffix));
static const char *header_sufs[]={
".hpp",
".hxx",
".h",
"",
};
for (size_t j=0;j<sizeof(header_sufs)/sizeof(header_sufs[0]);j++){
string org_suf(header_sufs[j]);
if (org_suf==""){
//outname+=new_suf;
break;
}
string::size_type p=outname.find(org_suf);
if (p!=string::npos){
outname.replace(p, org_suf.length(), ""/*new_suf*/);
break;
}
}
try{
vector<reflect_base*> refs;
<<<ADDREFLECTS>>>
infos[i].f(refs, outname);
}
catch(exception& e){
cerr<<"generate error: "<<e.what()<<endl;
unlink(outname.c_str());
}
return 0;
}
}
cerr<<"language "<<lang<<" is not supported"<<endl;
return 0;
}
| 22.703297 | 72 | 0.592933 | tkng |
b30559bb90a65e2741c449c685c11b55ca97437d | 2,517 | cpp | C++ | src/DecisionEngine/ConstrainedResource/CalculatedWorkingSystem.cpp | davidbrownell/DavidBrownell_DecisionEngine | f331b57f7b5ab4a5de84595f79df191fc0c13fba | [
"BSL-1.0"
] | null | null | null | src/DecisionEngine/ConstrainedResource/CalculatedWorkingSystem.cpp | davidbrownell/DavidBrownell_DecisionEngine | f331b57f7b5ab4a5de84595f79df191fc0c13fba | [
"BSL-1.0"
] | null | null | null | src/DecisionEngine/ConstrainedResource/CalculatedWorkingSystem.cpp | davidbrownell/DavidBrownell_DecisionEngine | f331b57f7b5ab4a5de84595f79df191fc0c13fba | [
"BSL-1.0"
] | null | null | null | /////////////////////////////////////////////////////////////////////////
///
/// \file CalculatedWorkingSystem.cpp
/// \brief See CalculatedWorkingSystem.h
///
/// \author David Brownell <db@DavidBrownell.com>
/// \date 2020-06-24 15:36:38
///
/// \note
///
/// \bug
///
/////////////////////////////////////////////////////////////////////////
///
/// \attention
/// Copyright David Brownell 2020-21
/// Distributed under the Boost Software License, Version 1.0. See
/// accompanying file LICENSE_1_0.txt or copy at
/// http://www.boost.org/LICENSE_1_0.txt.
///
/////////////////////////////////////////////////////////////////////////
#include "CalculatedWorkingSystem.h"
namespace DecisionEngine {
namespace ConstrainedResource {
// ----------------------------------------------------------------------
// |
// | CalculatedWorkingSystem
// |
// ----------------------------------------------------------------------
CalculatedWorkingSystem::CalculatedWorkingSystem(WorkingSystem::ImmutableStatePtr pImmutableState, WorkingSystem::TransitionState transition, Score score, Index index) :
Core::Components::CalculatedWorkingSystem(std::move(score), std::move(index)),
_pImmutableState(
std::move(
[&pImmutableState](void) -> WorkingSystem::ImmutableStatePtr & {
ENSURE_ARGUMENT(pImmutableState);
return pImmutableState;
}()
)
),
_transitionState(std::move(transition))
{}
std::string CalculatedWorkingSystem::ToString(void) const /*override*/ {
return boost::str(
boost::format("ConstrainedResource::CalculatedWorkingSystem(%1%,%2%)")
% GetScore().ToString()
% GetIndex().ToString()
);
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
CalculatedWorkingSystem::WorkingSystemPtr CalculatedWorkingSystem::CommitImpl(Score score, Index index) /*override*/ {
return std::make_shared<WorkingSystem>(
std::move(_pImmutableState),
std::move(_transitionState),
std::move(score),
std::move(index)
);
}
} // namespace ConstrainedResource
} // namespace DecisionEngine
SERIALIZATION_POLYMORPHIC_DEFINE(DecisionEngine::ConstrainedResource::CalculatedWorkingSystem);
| 36.478261 | 170 | 0.496623 | davidbrownell |
b308af6133ea26fee0b6963122a63fc74bb85293 | 1,801 | cpp | C++ | aws-cpp-sdk-cognito-idp/source/model/CustomSMSLambdaVersionConfigType.cpp | perfectrecall/aws-sdk-cpp | fb8cbebf2fd62720b65aeff841ad2950e73d8ebd | [
"Apache-2.0"
] | 1 | 2022-02-10T08:06:54.000Z | 2022-02-10T08:06:54.000Z | aws-cpp-sdk-cognito-idp/source/model/CustomSMSLambdaVersionConfigType.cpp | perfectrecall/aws-sdk-cpp | fb8cbebf2fd62720b65aeff841ad2950e73d8ebd | [
"Apache-2.0"
] | 1 | 2021-10-14T16:57:00.000Z | 2021-10-18T10:47:24.000Z | aws-cpp-sdk-cognito-idp/source/model/CustomSMSLambdaVersionConfigType.cpp | ravindra-wagh/aws-sdk-cpp | 7d5ff01b3c3b872f31ca98fb4ce868cd01e97696 | [
"Apache-2.0"
] | 1 | 2021-11-09T12:02:58.000Z | 2021-11-09T12:02:58.000Z | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/cognito-idp/model/CustomSMSLambdaVersionConfigType.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
namespace Aws
{
namespace CognitoIdentityProvider
{
namespace Model
{
CustomSMSLambdaVersionConfigType::CustomSMSLambdaVersionConfigType() :
m_lambdaVersion(CustomSMSSenderLambdaVersionType::NOT_SET),
m_lambdaVersionHasBeenSet(false),
m_lambdaArnHasBeenSet(false)
{
}
CustomSMSLambdaVersionConfigType::CustomSMSLambdaVersionConfigType(JsonView jsonValue) :
m_lambdaVersion(CustomSMSSenderLambdaVersionType::NOT_SET),
m_lambdaVersionHasBeenSet(false),
m_lambdaArnHasBeenSet(false)
{
*this = jsonValue;
}
CustomSMSLambdaVersionConfigType& CustomSMSLambdaVersionConfigType::operator =(JsonView jsonValue)
{
if(jsonValue.ValueExists("LambdaVersion"))
{
m_lambdaVersion = CustomSMSSenderLambdaVersionTypeMapper::GetCustomSMSSenderLambdaVersionTypeForName(jsonValue.GetString("LambdaVersion"));
m_lambdaVersionHasBeenSet = true;
}
if(jsonValue.ValueExists("LambdaArn"))
{
m_lambdaArn = jsonValue.GetString("LambdaArn");
m_lambdaArnHasBeenSet = true;
}
return *this;
}
JsonValue CustomSMSLambdaVersionConfigType::Jsonize() const
{
JsonValue payload;
if(m_lambdaVersionHasBeenSet)
{
payload.WithString("LambdaVersion", CustomSMSSenderLambdaVersionTypeMapper::GetNameForCustomSMSSenderLambdaVersionType(m_lambdaVersion));
}
if(m_lambdaArnHasBeenSet)
{
payload.WithString("LambdaArn", m_lambdaArn);
}
return payload;
}
} // namespace Model
} // namespace CognitoIdentityProvider
} // namespace Aws
| 23.697368 | 143 | 0.783454 | perfectrecall |
b30fd875160d3b2f84a44a43a43edfd925a1826e | 15,748 | cpp | C++ | src/xtd.drawing/src/xtd/drawing/brushes.cpp | ExternalRepositories/xtd | 5889d69900ad22a00fcb640d7850a1d599cf593a | [
"MIT"
] | 251 | 2019-04-20T02:02:24.000Z | 2022-03-31T09:52:08.000Z | src/xtd.drawing/src/xtd/drawing/brushes.cpp | leanid/xtd | 2e1ea6537218788ca08901faf8915d4100990b53 | [
"MIT"
] | 29 | 2021-01-07T12:52:12.000Z | 2022-03-29T08:42:14.000Z | src/xtd.drawing/src/xtd/drawing/brushes.cpp | leanid/xtd | 2e1ea6537218788ca08901faf8915d4100990b53 | [
"MIT"
] | 27 | 2019-11-21T02:37:44.000Z | 2022-03-30T22:59:14.000Z | #include "../../../include/xtd/drawing/brushes.h"
using namespace xtd::drawing;
solid_brush brushes::transparent() {
return solid_brush(color::from_known_color(known_color::transparent));
}
solid_brush brushes::alice_blue() {
return solid_brush(color::from_known_color(known_color::alice_blue));
}
solid_brush brushes::antique_white() {
return solid_brush(color::from_known_color(known_color::antique_white));
}
solid_brush brushes::aqua() {
return solid_brush(color::from_known_color(known_color::aqua));
}
solid_brush brushes::aquamarine() {
return solid_brush(color::from_known_color(known_color::aquamarine));
}
solid_brush brushes::azure() {
return solid_brush(color::from_known_color(known_color::azure));
}
solid_brush brushes::beige() {
return solid_brush(color::from_known_color(known_color::beige));
}
solid_brush brushes::bisque() {
return solid_brush(color::from_known_color(known_color::bisque));
}
solid_brush brushes::black() {
return solid_brush(color::from_known_color(known_color::black));
}
solid_brush brushes::blanched_almond() {
return solid_brush(color::from_known_color(known_color::blanched_almond));
}
solid_brush brushes::blue() {
return solid_brush(color::from_known_color(known_color::blue));
}
solid_brush brushes::blue_violet() {
return solid_brush(color::from_known_color(known_color::blue_violet));
}
solid_brush brushes::brown() {
return solid_brush(color::from_known_color(known_color::brown));
}
solid_brush brushes::burly_wood() {
return solid_brush(color::from_known_color(known_color::burly_wood));
}
solid_brush brushes::cadet_blue() {
return solid_brush(color::from_known_color(known_color::cadet_blue));
}
solid_brush brushes::chartreuse() {
return solid_brush(color::from_known_color(known_color::chartreuse));
}
solid_brush brushes::chocolate() {
return solid_brush(color::from_known_color(known_color::chocolate));
}
solid_brush brushes::coral() {
return solid_brush(color::from_known_color(known_color::coral));
}
solid_brush brushes::cornflower_blue() {
return solid_brush(color::from_known_color(known_color::cornflower_blue));
}
solid_brush brushes::cornsilk() {
return solid_brush(color::from_known_color(known_color::cornsilk));
}
solid_brush brushes::crimson() {
return solid_brush(color::from_known_color(known_color::crimson));
}
solid_brush brushes::cyan() {
return solid_brush(color::from_known_color(known_color::cyan));
}
solid_brush brushes::dark_blue() {
return solid_brush(color::from_known_color(known_color::dark_blue));
}
solid_brush brushes::dark_cyan() {
return solid_brush(color::from_known_color(known_color::dark_cyan));
}
solid_brush brushes::dark_goldenrod() {
return solid_brush(color::from_known_color(known_color::dark_goldenrod));
}
solid_brush brushes::dark_gray() {
return solid_brush(color::from_known_color(known_color::dark_gray));
}
solid_brush brushes::dark_green() {
return solid_brush(color::from_known_color(known_color::dark_green));
}
solid_brush brushes::dark_khaki() {
return solid_brush(color::from_known_color(known_color::dark_khaki));
}
solid_brush brushes::dark_magenta() {
return solid_brush(color::from_known_color(known_color::dark_magenta));
}
solid_brush brushes::dark_olive_green() {
return solid_brush(color::from_known_color(known_color::dark_olive_green));
}
solid_brush brushes::dark_orange() {
return solid_brush(color::from_known_color(known_color::dark_orange));
}
solid_brush brushes::dark_orchid() {
return solid_brush(color::from_known_color(known_color::dark_orchid));
}
solid_brush brushes::dark_red() {
return solid_brush(color::from_known_color(known_color::dark_red));
}
solid_brush brushes::dark_salmon() {
return solid_brush(color::from_known_color(known_color::dark_salmon));
}
solid_brush brushes::dark_sea_green() {
return solid_brush(color::from_known_color(known_color::dark_sea_green));
}
solid_brush brushes::dark_slate_blue() {
return solid_brush(color::from_known_color(known_color::dark_slate_blue));
}
solid_brush brushes::dark_slate_gray() {
return solid_brush(color::from_known_color(known_color::dark_slate_gray));
}
solid_brush brushes::dark_turquoise() {
return solid_brush(color::from_known_color(known_color::dark_turquoise));
}
solid_brush brushes::dark_violet() {
return solid_brush(color::from_known_color(known_color::dark_violet));
}
solid_brush brushes::deep_pink() {
return solid_brush(color::from_known_color(known_color::deep_pink));
}
solid_brush brushes::deep_sky_blue() {
return solid_brush(color::from_known_color(known_color::deep_sky_blue));
}
solid_brush brushes::dim_gray() {
return solid_brush(color::from_known_color(known_color::dim_gray));
}
solid_brush brushes::dodger_blue() {
return solid_brush(color::from_known_color(known_color::dodger_blue));
}
solid_brush brushes::firebrick() {
return solid_brush(color::from_known_color(known_color::firebrick));
}
solid_brush brushes::floral_white() {
return solid_brush(color::from_known_color(known_color::floral_white));
}
solid_brush brushes::forest_green() {
return solid_brush(color::from_known_color(known_color::forest_green));
}
solid_brush brushes::fuchsia() {
return solid_brush(color::from_known_color(known_color::fuchsia));
}
solid_brush brushes::gainsboro() {
return solid_brush(color::from_known_color(known_color::gainsboro));
}
solid_brush brushes::ghost_white() {
return solid_brush(color::from_known_color(known_color::ghost_white));
}
solid_brush brushes::gold() {
return solid_brush(color::from_known_color(known_color::gold));
}
solid_brush brushes::goldenrod() {
return solid_brush(color::from_known_color(known_color::goldenrod));
}
solid_brush brushes::gray() {
return solid_brush(color::from_known_color(known_color::gray));
}
solid_brush brushes::green() {
return solid_brush(color::from_known_color(known_color::green));
}
solid_brush brushes::green_yellow() {
return solid_brush(color::from_known_color(known_color::green_yellow));
}
solid_brush brushes::honeydew() {
return solid_brush(color::from_known_color(known_color::honeydew));
}
solid_brush brushes::hot_pink() {
return solid_brush(color::from_known_color(known_color::hot_pink));
}
solid_brush brushes::indian_red() {
return solid_brush(color::from_known_color(known_color::indian_red));
}
solid_brush brushes::indigo() {
return solid_brush(color::from_known_color(known_color::indigo));
}
solid_brush brushes::ivory() {
return solid_brush(color::from_known_color(known_color::ivory));
}
solid_brush brushes::khaki() {
return solid_brush(color::from_known_color(known_color::khaki));
}
solid_brush brushes::lavender() {
return solid_brush(color::from_known_color(known_color::lavender));
}
solid_brush brushes::lavender_blush() {
return solid_brush(color::from_known_color(known_color::lavender_blush));
}
solid_brush brushes::lawn_green() {
return solid_brush(color::from_known_color(known_color::lawn_green));
}
solid_brush brushes::lemon_chiffon() {
return solid_brush(color::from_known_color(known_color::lemon_chiffon));
}
solid_brush brushes::light_blue() {
return solid_brush(color::from_known_color(known_color::light_blue));
}
solid_brush brushes::light_coral() {
return solid_brush(color::from_known_color(known_color::light_coral));
}
solid_brush brushes::light_cyan() {
return solid_brush(color::from_known_color(known_color::light_cyan));
}
solid_brush brushes::light_goldenrod_yellow() {
return solid_brush(color::from_known_color(known_color::light_goldenrod_yellow));
}
solid_brush brushes::light_gray() {
return solid_brush(color::from_known_color(known_color::light_gray));
}
solid_brush brushes::light_green() {
return solid_brush(color::from_known_color(known_color::light_green));
}
solid_brush brushes::light_pink() {
return solid_brush(color::from_known_color(known_color::light_pink));
}
solid_brush brushes::light_salmon() {
return solid_brush(color::from_known_color(known_color::light_salmon));
}
solid_brush brushes::light_sea_green() {
return solid_brush(color::from_known_color(known_color::light_sea_green));
}
solid_brush brushes::light_sky_blue() {
return solid_brush(color::from_known_color(known_color::light_sky_blue));
}
solid_brush brushes::light_slate_gray() {
return solid_brush(color::from_known_color(known_color::light_slate_gray));
}
solid_brush brushes::light_steel_blue() {
return solid_brush(color::from_known_color(known_color::light_steel_blue));
}
solid_brush brushes::light_yellow() {
return solid_brush(color::from_known_color(known_color::light_yellow));
}
solid_brush brushes::lime() {
return solid_brush(color::from_known_color(known_color::lime));
}
solid_brush brushes::lime_green() {
return solid_brush(color::from_known_color(known_color::lime_green));
}
solid_brush brushes::linen() {
return solid_brush(color::from_known_color(known_color::linen));
}
solid_brush brushes::magenta() {
return solid_brush(color::from_known_color(known_color::magenta));
}
solid_brush brushes::maroon() {
return solid_brush(color::from_known_color(known_color::maroon));
}
solid_brush brushes::medium_aquamarine() {
return solid_brush(color::from_known_color(known_color::medium_aquamarine));
}
solid_brush brushes::medium_blue() {
return solid_brush(color::from_known_color(known_color::medium_blue));
}
solid_brush brushes::medium_orchid() {
return solid_brush(color::from_known_color(known_color::medium_orchid));
}
solid_brush brushes::medium_purple() {
return solid_brush(color::from_known_color(known_color::medium_purple));
}
solid_brush brushes::medium_sea_green() {
return solid_brush(color::from_known_color(known_color::medium_sea_green));
}
solid_brush brushes::medium_slate_blue() {
return solid_brush(color::from_known_color(known_color::medium_slate_blue));
}
solid_brush brushes::medium_spring_green() {
return solid_brush(color::from_known_color(known_color::medium_spring_green));
}
solid_brush brushes::medium_turquoise() {
return solid_brush(color::from_known_color(known_color::medium_turquoise));
}
solid_brush brushes::medium_violet_red() {
return solid_brush(color::from_known_color(known_color::medium_violet_red));
}
solid_brush brushes::midnight_blue() {
return solid_brush(color::from_known_color(known_color::midnight_blue));
}
solid_brush brushes::mint_cream() {
return solid_brush(color::from_known_color(known_color::mint_cream));
}
solid_brush brushes::misty_rose() {
return solid_brush(color::from_known_color(known_color::misty_rose));
}
solid_brush brushes::moccasin() {
return solid_brush(color::from_known_color(known_color::moccasin));
}
solid_brush brushes::navajo_white() {
return solid_brush(color::from_known_color(known_color::navajo_white));
}
solid_brush brushes::navy() {
return solid_brush(color::from_known_color(known_color::navy));
}
solid_brush brushes::old_lace() {
return solid_brush(color::from_known_color(known_color::old_lace));
}
solid_brush brushes::olive() {
return solid_brush(color::from_known_color(known_color::olive));
}
solid_brush brushes::olive_drab() {
return solid_brush(color::from_known_color(known_color::olive_drab));
}
solid_brush brushes::orange() {
return solid_brush(color::from_known_color(known_color::orange));
}
solid_brush brushes::orange_red() {
return solid_brush(color::from_known_color(known_color::orange_red));
}
solid_brush brushes::orchid() {
return solid_brush(color::from_known_color(known_color::orchid));
}
solid_brush brushes::pale_goldenrod() {
return solid_brush(color::from_known_color(known_color::pale_goldenrod));
}
solid_brush brushes::pale_green() {
return solid_brush(color::from_known_color(known_color::pale_green));
}
solid_brush brushes::pale_turquoise() {
return solid_brush(color::from_known_color(known_color::pale_turquoise));
}
solid_brush brushes::pale_violet_red() {
return solid_brush(color::from_known_color(known_color::pale_violet_red));
}
solid_brush brushes::papaya_whip() {
return solid_brush(color::from_known_color(known_color::papaya_whip));
}
solid_brush brushes::peach_puff() {
return solid_brush(color::from_known_color(known_color::peach_puff));
}
solid_brush brushes::peru() {
return solid_brush(color::from_known_color(known_color::peru));
}
solid_brush brushes::pink() {
return solid_brush(color::from_known_color(known_color::pink));
}
solid_brush brushes::plum() {
return solid_brush(color::from_known_color(known_color::plum));
}
solid_brush brushes::powder_blue() {
return solid_brush(color::from_known_color(known_color::powder_blue));
}
solid_brush brushes::purple() {
return solid_brush(color::from_known_color(known_color::purple));
}
solid_brush brushes::rebecca_purple() {
return solid_brush(color::from_known_color(known_color::rebecca_purple));
}
solid_brush brushes::red() {
return solid_brush(color::from_known_color(known_color::red));
}
solid_brush brushes::rosy_brown() {
return solid_brush(color::from_known_color(known_color::rosy_brown));
}
solid_brush brushes::royal_blue() {
return solid_brush(color::from_known_color(known_color::royal_blue));
}
solid_brush brushes::saddle_brown() {
return solid_brush(color::from_known_color(known_color::saddle_brown));
}
solid_brush brushes::salmon() {
return solid_brush(color::from_known_color(known_color::salmon));
}
solid_brush brushes::sandy_brown() {
return solid_brush(color::from_known_color(known_color::sandy_brown));
}
solid_brush brushes::sea_green() {
return solid_brush(color::from_known_color(known_color::sea_green));
}
solid_brush brushes::sea_shell() {
return solid_brush(color::from_known_color(known_color::sea_shell));
}
solid_brush brushes::sienna() {
return solid_brush(color::from_known_color(known_color::sienna));
}
solid_brush brushes::silver() {
return solid_brush(color::from_known_color(known_color::silver));
}
solid_brush brushes::sky_blue() {
return solid_brush(color::from_known_color(known_color::sky_blue));
}
solid_brush brushes::slate_blue() {
return solid_brush(color::from_known_color(known_color::slate_blue));
}
solid_brush brushes::slate_gray() {
return solid_brush(color::from_known_color(known_color::slate_gray));
}
solid_brush brushes::snow() {
return solid_brush(color::from_known_color(known_color::snow));
}
solid_brush brushes::spring_green() {
return solid_brush(color::from_known_color(known_color::spring_green));
}
solid_brush brushes::steel_blue() {
return solid_brush(color::from_known_color(known_color::steel_blue));
}
solid_brush brushes::tan() {
return solid_brush(color::from_known_color(known_color::tan));
}
solid_brush brushes::teal() {
return solid_brush(color::from_known_color(known_color::teal));
}
solid_brush brushes::thistle() {
return solid_brush(color::from_known_color(known_color::thistle));
}
solid_brush brushes::tomato() {
return solid_brush(color::from_known_color(known_color::tomato));
}
solid_brush brushes::turquoise() {
return solid_brush(color::from_known_color(known_color::turquoise));
}
solid_brush brushes::violet() {
return solid_brush(color::from_known_color(known_color::violet));
}
solid_brush brushes::wheat() {
return solid_brush(color::from_known_color(known_color::wheat));
}
solid_brush brushes::white() {
return solid_brush(color::from_known_color(known_color::white));
}
solid_brush brushes::white_smoke() {
return solid_brush(color::from_known_color(known_color::white_smoke));
}
solid_brush brushes::yellow() {
return solid_brush(color::from_known_color(known_color::yellow));
}
solid_brush brushes::yellow_green() {
return solid_brush(color::from_known_color(known_color::yellow_green));
}
| 27.483421 | 83 | 0.781941 | ExternalRepositories |
b316a9dbc71148e4e734dedd9990719f082bc5ad | 1,454 | cpp | C++ | matslise/matslise/periodic.cpp | twist-numerical/matslise | ccce2bd3359963cfdd4b9686cb7b263754e77e7e | [
"MIT"
] | 4 | 2020-08-27T10:10:08.000Z | 2020-09-03T14:06:16.000Z | matslise/matslise/periodic.cpp | twist-numerical/matslise | ccce2bd3359963cfdd4b9686cb7b263754e77e7e | [
"MIT"
] | 7 | 2019-12-16T09:37:59.000Z | 2020-12-01T15:03:00.000Z | matslise/matslise/periodic.cpp | twist-numerical/matslise | ccce2bd3359963cfdd4b9686cb7b263754e77e7e | [
"MIT"
] | 1 | 2020-08-27T14:02:25.000Z | 2020-08-27T14:02:25.000Z | #include "../matslise.h"
#include "../util/find_sector.h"
#include "../util/constants.h"
using namespace matslise;
using namespace Eigen;
using namespace std;
template<typename Scalar>
pair<Y<Scalar, 1, 2>, Array<Scalar, 2, 1>>
PeriodicMatslise<Scalar>::propagate(
const Scalar &E, const Y<Scalar, 1, 2> &y,
const Scalar &a, const Scalar &b, bool use_h) const {
return matslise.template propagate<2>(E, y, a, b, use_h);
}
template<typename Scalar>
tuple<Scalar, Scalar, Array<Scalar, 2, 1>>
PeriodicMatslise<Scalar>::matchingError(const Scalar &E, bool use_h) const {
Y<Scalar, 1, 2> l = Y<Scalar, 1, 2>::Periodic();
Y<Scalar, 1, 2> r = Y<Scalar, 1, 2>::Periodic();
Array<Scalar, 2, 1> thetaL, thetaR;
tie(l, thetaL) = propagate(E, l, matslise.domain.min(), matslise.sectors[matslise.matchIndex]->max, use_h);
tie(r, thetaR) = propagate(E, r, matslise.domain.max(), matslise.sectors[matslise.matchIndex]->max, use_h);
Matrix<Scalar, 2, 2> err = l.y() - r.y();
Matrix<Scalar, 2, 2> dErr = l.ydE() - r.ydE();
Scalar error = err(0, 0) * err(1, 1) - err(0, 1) * err(1, 0);
Scalar dError = dErr(0, 0) * err(1, 1) + err(0, 0) * dErr(1, 1) - dErr(0, 1) * err(1, 0) - err(0, 1) * dErr(1, 0);
Array<Scalar, 2, 1> theta = thetaL - thetaR;
theta /= constants<Scalar>::PI;
theta[1] += 1; // adjust for initial conditions
return make_tuple(error, dError, theta);
}
#include "instantiate.h"
| 39.297297 | 118 | 0.634801 | twist-numerical |
b317cf9c548ebd9e6e16c605107aea308bfd37cc | 895 | cpp | C++ | qwertyattack/KeyPresses.cpp | tblock007/qwertyattack | 9b02531fa896ca269dbaeb1611cc2cc0bbf41de9 | [
"MIT"
] | 1 | 2019-09-11T18:47:52.000Z | 2019-09-11T18:47:52.000Z | qwertyattack/KeyPresses.cpp | tblock007/qwertyattack | 9b02531fa896ca269dbaeb1611cc2cc0bbf41de9 | [
"MIT"
] | null | null | null | qwertyattack/KeyPresses.cpp | tblock007/qwertyattack | 9b02531fa896ca269dbaeb1611cc2cc0bbf41de9 | [
"MIT"
] | 1 | 2019-09-26T03:34:28.000Z | 2019-09-26T03:34:28.000Z | #include "KeyPresses.hpp"
#include <SFML/Config.hpp>
#include "constants.hpp"
namespace qa {
KeyPresses::KeyPresses() : pressMask_(0)
{
}
KeyPresses::KeyPresses(sf::Uint32 mask) : pressMask_(mask)
{
}
void KeyPresses::reset()
{
pressMask_ = 0;
}
bool KeyPresses::isPressed(sf::Int32 i) const
{
return ((pressMask_ & (1 << i)) != 0);
}
bool KeyPresses::isPressed(char c) const
{
return isPressed(static_cast<sf::Int32>(c) - static_cast<sf::Int32>('A'));
}
void KeyPresses::setPressed(sf::Int32 i)
{
pressMask_ = pressMask_ | (1 << i);
}
void KeyPresses::setPressed(char c)
{
setPressed(static_cast<sf::Int32>(c) - static_cast<sf::Int32>('A'));
}
void KeyPresses::resetPressed(sf::Int32 i)
{
pressMask_ = pressMask_ & ~(1 << i);
}
void KeyPresses::resetPressed(char c)
{
resetPressed(static_cast<sf::Int32>(c) - static_cast<sf::Int32>('A'));
}
} // namespace qa
| 16.886792 | 77 | 0.667039 | tblock007 |
b31b497d78db30005717f378e2c9bee7f0e8530f | 376 | cpp | C++ | source/tiny_string_test.cpp | TerrySoba/DosPlatformGame | ce688db9e5b9fb1db6180774c73aeb0aeb16f4a8 | [
"MIT"
] | null | null | null | source/tiny_string_test.cpp | TerrySoba/DosPlatformGame | ce688db9e5b9fb1db6180774c73aeb0aeb16f4a8 | [
"MIT"
] | null | null | null | source/tiny_string_test.cpp | TerrySoba/DosPlatformGame | ce688db9e5b9fb1db6180774c73aeb0aeb16f4a8 | [
"MIT"
] | null | null | null | #include "unit_test.h"
#include "tiny_string.h"
#include <stdio.h>
TEST(StringConcatTest)
{
TinyString str1 = "Hello";
TinyString str2 = "World";
ASSERT_TRUE(str1 + str2 == "HelloWorld");
ASSERT_TRUE(str1 + "Game" == "HelloGame");
ASSERT_TRUE("Nice" + str2 == "NiceWorld");
ASSERT_TRUE(str1 + "" == "Hello");
ASSERT_TRUE("" + str2 == "World");
}
| 23.5 | 46 | 0.617021 | TerrySoba |
b31bc20245b1c2da9a5e82afcd552231ed788729 | 1,285 | cpp | C++ | src/lib/util/tests/TestUtToken.cpp | MarkLeone/PostHaste | 56083e30a58489338e39387981029488d7af2390 | [
"MIT"
] | 4 | 2015-05-07T03:29:52.000Z | 2016-08-29T17:30:15.000Z | src/lib/util/tests/TestUtToken.cpp | MarkLeone/PostHaste | 56083e30a58489338e39387981029488d7af2390 | [
"MIT"
] | 1 | 2018-05-14T04:41:04.000Z | 2018-05-14T04:41:04.000Z | src/lib/util/tests/TestUtToken.cpp | MarkLeone/PostHaste | 56083e30a58489338e39387981029488d7af2390 | [
"MIT"
] | null | null | null | #include "util/UtToken.h"
#include "util/UtTokenFactory.h"
#include <gtest/gtest.h>
#include <list>
#include <stdio.h>
#include <vector>
class TestUtToken : public testing::Test { };
TEST_F(TestUtToken, TestTokens)
{
UtTokenFactory factory;
UtToken t1 = factory.Get("foo");
UtToken t2 = factory.Get("foo");
UtToken t3 = factory.Get("bar");
EXPECT_TRUE(t1 == t2);
EXPECT_EQ(t1, t2);
EXPECT_TRUE(t1 != t3);
EXPECT_NE(t1, t3);
char* s1 = strdup("foo");
char* s2 = strdup("bar");
UtToken t4 = factory.Get(s1);
UtToken t5 = factory.Get(s2);
EXPECT_NE(t4, t5);
EXPECT_EQ(t1, t4);
EXPECT_EQ(t2, t4);
EXPECT_EQ(t3, t5);
std::string str1 = s1;
std::string str2 = s2;
UtToken t6 = factory.Get(str1);
UtToken t7 = factory.Get(str2);
EXPECT_NE(t6, t7);
EXPECT_TRUE(t1 == t6);
EXPECT_EQ(t2, t6);
EXPECT_EQ(t3, t7);
// Test explicit/implict conversion.
std::cout << static_cast<const char*>(t1) << std::endl;
std::cout << std::string(t1) << std::endl;
std::cout << t1 << std::endl;
const char* name1 = t1;
std::cout << name1 << std::endl;
free(s1);
free(s2);
}
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 23.363636 | 59 | 0.607004 | MarkLeone |
b31ca6d108369ab3e0a817dec4327a44c69d4763 | 36,105 | cpp | C++ | ExampleViewAllySkillPanel_publish/WarcraftIII_DLL_126-127/DotAAllstarsHelper/BlpReadWrite.cpp | UnrealKaraulov/DotaAllstarsHelper_DLL_FOR_DOTA | ed621a70540cdab03db8acc7cc6b80794363abcd | [
"Unlicense"
] | 1 | 2021-10-31T19:47:18.000Z | 2021-10-31T19:47:18.000Z | ExampleViewAllySkillPanel_publish/WarcraftIII_DLL_126-127/DotAAllstarsHelper/BlpReadWrite.cpp | UnrealKaraulov/DotaAllstarsHelper_DLL_FOR_DOTA | ed621a70540cdab03db8acc7cc6b80794363abcd | [
"Unlicense"
] | 1 | 2021-11-22T05:56:47.000Z | 2022-01-12T10:55:38.000Z | ExampleViewAllySkillPanel_publish/WarcraftIII_DLL_126-127/DotAAllstarsHelper/BlpReadWrite.cpp | UnrealKaraulov/DotaAllstarsHelper_DLL_FOR_DOTA | ed621a70540cdab03db8acc7cc6b80794363abcd | [
"Unlicense"
] | 1 | 2021-09-27T14:35:34.000Z | 2021-09-27T14:35:34.000Z | #include "BlpReadWrite.h"
BOOL IsPowerOfTwo( const long i )
{
long t = i;
while ( t % 2 == 0 )
t >>= 1;
return ( t == 1 );
}
BOOL GetFirstBytes( const char* filename, char* buffer, unsigned long length )
{
FILE* file;
fopen_s( &file, filename, "rb" );
if ( !file )
return FALSE;
if ( fread( buffer, 1, length, file ) < length )
{
fclose( file );
return FALSE;
}
fclose( file );
return TRUE;
}
BOOL MaskOk( unsigned char *mask, int expectedWidth, int expectedHeight, int expectedBpp, long &offset, const char *maskFile )
{
TGAHeader* header = ( TGAHeader* )mask;
if ( header->colorMapType != 0 || header->imageType != 2 || header->width == 0 || header->height == 0 )
return FALSE;
if ( header->width != expectedWidth || header->height != expectedHeight )
return FALSE;
if ( header->bpp / 8 != expectedBpp )
return FALSE;
offset = ( long )( sizeof( TGAHeader ) + header->imageIDLength );
return TRUE;
}
template<typename T>
inline void AssignWeightedPixel( double *target, T *source, double weight, int bytespp, BOOL add )
{
if ( !add )
{
target[ 0 ] = ( ( double )source[ 0 ] ) * weight;
target[ 1 ] = ( ( double )source[ 1 ] ) * weight;
target[ 2 ] = ( ( double )source[ 2 ] ) * weight;
if ( bytespp == 4 )
target[ 3 ] = ( ( double )source[ 3 ] ) * weight;
}
else
{
target[ 0 ] += ( ( double )source[ 0 ] ) * weight;
target[ 1 ] += ( ( double )source[ 1 ] ) * weight;
target[ 2 ] += ( ( double )source[ 2 ] ) * weight;
if ( bytespp == 4 )
target[ 3 ] += ( ( double )source[ 3 ] ) * weight;
}
}
inline unsigned char NormalizeComponent( double val )
{
if ( val < 0.0 )
return 0;
if ( val > ( double )0xFF )
return 0xFF;
return ( unsigned char )val;
}
static int* g_px1a = NULL;
static int g_px1a_w = 0;
static int* g_px1ab = NULL;
static int g_px1ab_w = 0;
void Resize_HQ_4ch( unsigned char* src, int w1, int h1,
int w2, int h2, StormBuffer& outdest )
{
unsigned char * dest = ( unsigned char * )Storm::MemAlloc( w2*h2 * 4 );
// Both buffers must be in ARGB format, and a scanline should be w*4 bytes.
// If pQuitFlag is non-NULL, then at the end of each scanline, it will check
// the value at *pQuitFlag; if it's set to 'true', this function will abort.
// (This is handy if you're background-loading an image, and decide to cancel.)
// NOTE: THIS WILL OVERFLOW for really major downsizing (2800x2800 to 1x1 or more)
// (2800 ~ sqrt(2^23)) - for a lazy fix, just call this in two passes.
/*assert( src );
assert( dest );
assert( w1 >= 1 );
assert( h1 >= 1 );
assert( w2 >= 1 );
assert( h2 >= 1 );
*/
// check for MMX (one time only)
if ( w2 * 2 == w1 && h2 * 2 == h1 )
{
// perfect 2x2:1 case - faster code
// (especially important because this is common for generating low (large) mip levels!)
DWORD *dsrc = ( DWORD* )src;
DWORD *ddest = ( DWORD* )dest;
DWORD remainder = 0;
int i = 0;
for ( int y2 = 0; y2 < h2; y2++ )
{
int y1 = y2 * 2;
DWORD* temp_src = &dsrc[ y1*w1 ];
for ( int x2 = 0; x2 < w2; x2++ )
{
DWORD xUL = temp_src[ 0 ];
DWORD xUR = temp_src[ 1 ];
DWORD xLL = temp_src[ w1 ];
DWORD xLR = temp_src[ w1 + 1 ];
// note: DWORD packing is 0xAARRGGBB
DWORD redblue = ( xUL & 0x00FF00FF ) + ( xUR & 0x00FF00FF ) + ( xLL & 0x00FF00FF ) + ( xLR & 0x00FF00FF ) + ( remainder & 0x00FF00FF );
DWORD green = ( xUL & 0x0000FF00 ) + ( xUR & 0x0000FF00 ) + ( xLL & 0x0000FF00 ) + ( xLR & 0x0000FF00 ) + ( remainder & 0x0000FF00 );
// redblue = 000000rr rrrrrrrr 000000bb bbbbbbbb
// green = xxxxxx00 000000gg gggggggg 00000000
remainder = ( redblue & 0x00030003 ) | ( green & 0x00000300 );
ddest[ i++ ] = ( ( redblue & 0x03FC03FC ) | ( green & 0x0003FC00 ) ) >> 2;
temp_src += 2;
}
}
}
else
{
// arbitrary resize.
unsigned int *dsrc = ( unsigned int * )src;
unsigned int *ddest = ( unsigned int * )dest;
bool bUpsampleX = ( w1 < w2 );
bool bUpsampleY = ( h1 < h2 );
// If too many input pixels map to one output pixel, our 32-bit accumulation values
// could overflow - so, if we have huge mappings like that, cut down the weights:
// 256 max color value
// *256 weight_x
// *256 weight_y
// *256 (16*16) maximum # of input pixels (x,y) - unless we cut the weights down...
int weight_shift = 0;
float source_texels_per_out_pixel = ( ( w1 / ( float )w2 + 1 )
* ( h1 / ( float )h2 + 1 )
);
float weight_per_pixel = source_texels_per_out_pixel * 256 * 256; //weight_x * weight_y
float accum_per_pixel = weight_per_pixel * 256; //color value is 0-255
float weight_div = accum_per_pixel / 4294967000.0f;
if ( weight_div > 1 )
weight_shift = ( int )ceilf( logf( ( float )weight_div ) / logf( 2.0f ) );
weight_shift = min( 15, weight_shift ); // this could go to 15 and still be ok.
float fh = 256 * h1 / ( float )h2;
float fw = 256 * w1 / ( float )w2;
if ( bUpsampleX && bUpsampleY )
{
// faster to just do 2x2 bilinear interp here
// cache x1a, x1b for all the columns:
// ...and your OS better have garbage collection on process exit :)
if ( g_px1a_w < w2 )
{
if ( g_px1a ) delete[ ] g_px1a;
g_px1a = new int[ w2 * 2 * 1 ];
g_px1a_w = w2 * 2;
}
for ( int x2 = 0; x2 < w2; x2++ )
{
// find the x-range of input pixels that will contribute:
int x1a = ( int )( x2*fw );
x1a = min( x1a, 256 * ( w1 - 1 ) - 1 );
g_px1a[ x2 ] = x1a;
}
// FOR EVERY OUTPUT PIXEL
for ( int y2 = 0; y2 < h2; y2++ )
{
// find the y-range of input pixels that will contribute:
int y1a = ( int )( y2*fh );
y1a = min( y1a, 256 * ( h1 - 1 ) - 1 );
int y1c = y1a >> 8;
unsigned int *ddest = &( ( unsigned int * )dest )[ y2*w2 + 0 ];
for ( int x2 = 0; x2 < w2; x2++ )
{
// find the x-range of input pixels that will contribute:
int x1a = g_px1a[ x2 ];//(int)(x2*fw);
int x1c = x1a >> 8;
unsigned int *dsrc2 = &dsrc[ y1c*w1 + x1c ];
// PERFORM BILINEAR INTERPOLATION on 2x2 pixels
unsigned int r = 0, g = 0, b = 0, a = 0;
unsigned int weight_x = 256 - ( x1a & 0xFF );
unsigned int weight_y = 256 - ( y1a & 0xFF );
for ( int y = 0; y < 2; y++ )
{
for ( int x = 0; x < 2; x++ )
{
unsigned int c = dsrc2[ x + y*w1 ];
unsigned int r_src = ( c ) & 0xFF;
unsigned int g_src = ( c >> 8 ) & 0xFF;
unsigned int b_src = ( c >> 16 ) & 0xFF;
unsigned int w = ( weight_x * weight_y ) >> weight_shift;
r += r_src * w;
g += g_src * w;
b += b_src * w;
weight_x = 256 - weight_x;
}
weight_y = 256 - weight_y;
}
unsigned int c = ( ( r >> 16 ) ) | ( ( g >> 8 ) & 0xFF00 ) | ( b & 0xFF0000 );
*ddest++ = c;//ddest[y2*w2 + x2] = c;
}
}
}
else
{
// cache x1a, x1b for all the columns:
// ...and your OS better have garbage collection on process exit :)
if ( g_px1ab_w < w2 )
{
if ( g_px1ab ) delete[ ] g_px1ab;
g_px1ab = new int[ w2 * 2 * 2 ];
g_px1ab_w = w2 * 2;
}
for ( int x2 = 0; x2 < w2; x2++ )
{
// find the x-range of input pixels that will contribute:
int x1a = ( int )( ( x2 )*fw );
int x1b = ( int )( ( x2 + 1 )*fw );
if ( bUpsampleX ) // map to same pixel -> we want to interpolate between two pixels!
x1b = x1a + 256;
x1b = min( x1b, 256 * w1 - 1 );
g_px1ab[ x2 * 2 + 0 ] = x1a;
g_px1ab[ x2 * 2 + 1 ] = x1b;
}
// FOR EVERY OUTPUT PIXEL
for ( int y2 = 0; y2 < h2; y2++ )
{
// find the y-range of input pixels that will contribute:
int y1a = ( int )( ( y2 )*fh );
int y1b = ( int )( ( y2 + 1 )*fh );
if ( bUpsampleY ) // map to same pixel -> we want to interpolate between two pixels!
y1b = y1a + 256;
y1b = min( y1b, 256 * h1 - 1 );
int y1c = y1a >> 8;
int y1d = y1b >> 8;
for ( int x2 = 0; x2 < w2; x2++ )
{
// find the x-range of input pixels that will contribute:
int x1a = g_px1ab[ x2 * 2 + 0 ]; // (computed earlier)
int x1b = g_px1ab[ x2 * 2 + 1 ]; // (computed earlier)
int x1c = x1a >> 8;
int x1d = x1b >> 8;
// ADD UP ALL INPUT PIXELS CONTRIBUTING TO THIS OUTPUT PIXEL:
unsigned int r = 0, g = 0, b = 0, a = 0;
for ( int y = y1c; y <= y1d; y++ )
{
unsigned int weight_y = 256;
if ( y1c != y1d )
{
if ( y == y1c )
weight_y = 256 - ( y1a & 0xFF );
else if ( y == y1d )
weight_y = ( y1b & 0xFF );
}
unsigned int *dsrc2 = &dsrc[ y*w1 + x1c ];
for ( int x = x1c; x <= x1d; x++ )
{
unsigned int weight_x = 256;
if ( x1c != x1d )
{
if ( x == x1c )
weight_x = 256 - ( x1a & 0xFF );
else if ( x == x1d )
weight_x = ( x1b & 0xFF );
}
unsigned int c = *dsrc2++;//dsrc[y*w1 + x];
unsigned int r_src = ( c ) & 0xFF;
unsigned int g_src = ( c >> 8 ) & 0xFF;
unsigned int b_src = ( c >> 16 ) & 0xFF;
unsigned int w = ( weight_x * weight_y ) >> weight_shift;
r += r_src * w;
g += g_src * w;
b += b_src * w;
a += w;
}
}
// write results
unsigned int c = ( ( r / a ) ) | ( ( g / a ) << 8 ) | ( ( b / a ) << 16 );
*ddest++ = c;//ddest[y2*w2 + x2] = c;
}
}
}
}
outdest.buf = ( char* )dest;
outdest.length = w2 * h2 * 4;
}
void ScaneImageSimple( unsigned char * data, int oldW, int oldH, int newW, int newH, int bytespp, StormBuffer & target )
{
unsigned char* newData = ( unsigned char * )Storm::MemAlloc( newW*newH*bytespp );
int maxpixel = oldW*oldH*bytespp - 4;
double scaleWidth = ( double )newW / ( double )oldW;
double scaleHeight = ( double )newH / ( double )oldH;
int pixel = 0;
for ( int cy = 0; cy < newH; cy++ ) {
for ( int cx = 0; cx < newW; cx++ ) {
int nearestMatch = ( ( int )( cy / scaleHeight )*( oldW * bytespp ) )
+ ( ( int )( cx / scaleWidth )*bytespp );
if ( nearestMatch > maxpixel )
{
nearestMatch = maxpixel;
}
newData[ pixel ] = data[ nearestMatch ];
newData[ pixel + 1 ] = data[ nearestMatch + 1 ];
newData[ pixel + 2 ] = data[ nearestMatch + 2 ];
if ( bytespp == 4 ) newData[ pixel + 3 ] = data[ nearestMatch + 3 ];
pixel += bytespp;
}
}
target.length = newW*newH*bytespp;
target.buf = ( char * )newData;
}
void ScaleImage( unsigned char* rawData, int oldW, int oldH, int newW, int newH, int bytespp, StormBuffer &target )
{
ScaneImageSimple( rawData, oldW, oldH, newW, newH, bytespp, target );
return;
/*if ( bytespp == 4 )
{
Resize_HQ_4ch( rawData, oldW, oldH, newW, newH, target );
return;
}
if ( oldW == newW && oldH == newH )
{
target.length = ( unsigned long )( newW * newH * bytespp );
target.buf = Storm::MemAlloc[ target.length ];
std::memcpy( target.buf, rawData, target.length );
return;
}
// scale horizontally
double* temp = new double[ ( unsigned int )( oldH * newW * bytespp ) ];
if ( oldW == newW )
{
for ( int i = 0; i < oldW * oldH * bytespp; i++ )
temp[ i ] = ( double )rawData[ i ];
}
else
{
double sum = 0;
double diffW = ( ( double )oldW / ( double )newW );
for ( int i = 0; i < newW; i++ )
{
double newSum = sum + diffW;
int pix = ( int )floor( sum );
double weight = min( diffW, 1.0 - fmod( sum, 1.0 ) );
for ( int j = 0; j < oldH; j++ )
AssignWeightedPixel( &temp[ ( j*newW + i )*bytespp ], &rawData[ ( j*oldW + pix )*bytespp ], ( weight / diffW ), bytespp, FALSE );
sum += weight;
while ( sum < newSum )
{
weight = min( newSum - sum, 1.0 );
pix++;
for ( int j = 0; j < oldH; j++ )
AssignWeightedPixel( &temp[ ( j*newW + i )*bytespp ], &rawData[ ( j*oldW + pix )*bytespp ], ( weight / diffW ), bytespp, TRUE );
sum += weight;
}
}
}
// scale vertically
target.length = ( unsigned long )( newW * newH * bytespp );
target.buf = Storm::MemAlloc[ target.length ];
double* final = new double[ target.length ];
if ( newH == oldH )
{
std::memcpy( final, temp, target.length * sizeof( double ) );
}
else
{
double sum = 0;
double diffH = ( ( double )oldH / ( double )newH );
for ( int j = 0; j < newH; j++ )
{
double newSum = sum + diffH;
int pix = ( int )floor( sum );
double weight = min( diffH, 1.0 - fmod( sum, 1.0 ) );
for ( int i = 0; i < newW; i++ )
AssignWeightedPixel( &final[ ( j*newW + i )*bytespp ], &temp[ ( pix*newW + i )*bytespp ], ( weight / diffH ), bytespp, FALSE );
sum += weight;
while ( sum < newSum )
{
weight = min( newSum - sum, 1.0 );
pix++;
for ( int i = 0; i < newW; i++ )
AssignWeightedPixel( &final[ ( j*newW + i )*bytespp ], &temp[ ( pix*newW + i )*bytespp ], ( weight / diffH ), bytespp, TRUE );
sum += weight;
}
}
}
for ( unsigned long i = 0; i < target.length; i++ )
target.buf[ i ] = ( char )NormalizeComponent( final[ i ] );
delete[ ] final;
delete[ ] temp;*/
}
void SubtractColor( unsigned char &pixel, unsigned char &mask )
{
if ( 0xFF - mask > pixel )
pixel = 0;
else
pixel -= ( 0xFF - mask );
}
void DivideColor( unsigned char &pixel, unsigned char &mask )
{
pixel = ( unsigned char )( ( double )pixel * ( ( double )mask / ( double )0xFF ) );
}
BOOL ApplyOverlay( unsigned char* rawData, unsigned char* mask, int width, int height, int bytespp, int maskBpp )
{
if ( !mask )
return FALSE;
for ( int i = 0; i < width * height; i++ )
{
DivideColor( rawData[ i*bytespp ], mask[ i*maskBpp ] );
DivideColor( rawData[ i*bytespp + 1 ], mask[ i*maskBpp + 1 ] );
DivideColor( rawData[ i*bytespp + 2 ], mask[ i*maskBpp + 2 ] );
if ( bytespp == 4 && maskBpp == 4 )
DivideColor( rawData[ i*bytespp + 3 ], mask[ i*maskBpp + 3 ] );
}
return TRUE;
}
BOOL ApplyBorder( unsigned char* rawData, unsigned char* mask, int width, int height, int bytespp, int borderBpp )
{
if ( !mask )
return FALSE;
if ( borderBpp == 4 )
{
for ( int i = 0; i < width * height; i++ )
{
if ( mask[ i*borderBpp + 3 ] == 0xFF )
{ // no transparence
rawData[ i*bytespp ] = mask[ i*borderBpp ];
rawData[ i*bytespp + 1 ] = mask[ i*borderBpp + 1 ];
rawData[ i*bytespp + 2 ] = mask[ i*borderBpp + 2 ];
if ( bytespp == 4 )
rawData[ i*bytespp + 3 ] = mask[ i*borderBpp + 3 ];
}
else if ( mask[ i*borderBpp + 3 ] == 0x00 )
{ // full transparence
rawData[ i*bytespp ] = rawData[ i*bytespp + 1 ] = rawData[ i*bytespp + 2 ] = 0x00;
if ( bytespp == 4 )
rawData[ i*bytespp + 3 ] = 0x00;
}
}
}
else
{
for ( int i = 0; i < width * height; i++ )
{
if ( mask[ i*borderBpp ] != 0xFF || mask[ i*borderBpp + 1 ] != 0xFF || mask[ i*borderBpp + 2 ] != 0xFF )
{ // not white
rawData[ i*bytespp ] = mask[ i*borderBpp ];
rawData[ i*bytespp + 1 ] = mask[ i*borderBpp + 1 ];
rawData[ i*bytespp + 2 ] = mask[ i*borderBpp + 2 ];
}
}
}
return TRUE;
}
int GetRequiredMipMaps( int width, int height )
{
int mips = 0;
while ( width > 0 && height > 0 )
{
mips++;
width = width / 2;
height = height / 2;
}
return mips;
}
void * ReadImage( int &width,
int &height,
int &nchannels,
const void *buffer,
int sizebytes )
{
JPEG_CORE_PROPERTIES jcprops = JPEG_CORE_PROPERTIES( );
if ( ijlInit( &jcprops ) != IJL_OK )
{
ijlFree( &jcprops );
MessageBoxA( 0, "IJL INIT ERROR", " Success ! ", 0 );
return NULL;
}
nchannels = 4;
unsigned char * pixbuff = ( unsigned char * )Storm::MemAlloc( width*height*nchannels );
if ( !pixbuff )
{
ijlFree( &jcprops );
MessageBoxA( 0, "pixbuff ERROR", " Success ! ", 0 );
return NULL;
}
jcprops.UseJPEGPROPERTIES = 0;
jcprops.DIBBytes = ( unsigned char * )pixbuff;
jcprops.DIBWidth = width;
jcprops.DIBHeight = height;
jcprops.DIBPadBytes = 0;
jcprops.DIBChannels = nchannels;
jcprops.DIBColor = IJL_OTHER;
jcprops.DIBSubsampling = IJL_NONE;
jcprops.JPGFile = NULL;
jcprops.JPGBytes = ( unsigned char * )buffer;
jcprops.JPGSizeBytes = sizebytes;
jcprops.JPGWidth = width;
jcprops.JPGHeight = height;
jcprops.JPGChannels = nchannels;
jcprops.JPGColor = IJL_OTHER;
jcprops.JPGSubsampling = IJL_NONE;
jcprops.JPGThumbWidth = 0;
jcprops.JPGThumbHeight = 0;
jcprops.cconversion_reqd = 1;
jcprops.upsampling_reqd = 1;
jcprops.jquality = 75;
if ( ijlRead( &jcprops, IJL_JBUFF_READWHOLEIMAGE ) != IJL_OK )
{
ijlFree( &jcprops );
MessageBoxA( 0, "IJL_JBUFF_READWHOLEIMAGE ERROR", " Success ! ", 0 );
return NULL;
}
if ( ijlFree( &jcprops ) != IJL_OK )
{
MessageBoxA( 0, "ijlFree ERROR", " Success ! ", 0 );
return 0;
}
return ( void * )pixbuff;
}
void * Compress( const void *source,
int width,
int height,
int bpp,
int &len,
int quality )
{
JPEG_CORE_PROPERTIES jcprops;
if ( ijlInit( &jcprops ) != IJL_OK )
{
ijlFree( &jcprops );
return 0;
}
jcprops.DIBWidth = width;
jcprops.DIBHeight = height;
jcprops.JPGWidth = width;
jcprops.JPGHeight = height;
jcprops.DIBBytes = ( unsigned char * )source;
jcprops.DIBPadBytes = 0;
jcprops.DIBChannels = bpp;
jcprops.JPGChannels = bpp;
if ( bpp == 3 )
{
jcprops.DIBColor = IJL_RGB;
jcprops.JPGColor = IJL_YCBCR;
jcprops.JPGSubsampling = IJL_411;
jcprops.DIBSubsampling = ( IJL_DIBSUBSAMPLING )0;
}
else
{
jcprops.DIBColor = IJL_G;
jcprops.JPGColor = IJL_G;
jcprops.JPGSubsampling = ( IJL_JPGSUBSAMPLING )0;
jcprops.DIBSubsampling = ( IJL_DIBSUBSAMPLING )0;
}
int size = width*height*bpp;
unsigned char * buffer = ( unsigned char * )Storm::MemAlloc( size );
jcprops.JPGSizeBytes = size;
jcprops.JPGBytes = buffer;
jcprops.jquality = quality;
if ( ijlWrite( &jcprops, IJL_JBUFF_WRITEWHOLEIMAGE ) != IJL_OK )
{
ijlFree( &jcprops );
Storm::MemFree( buffer );
return 0;
}
if ( ijlFree( &jcprops ) != IJL_OK )
{
Storm::MemFree( buffer );
return 0;
}
len = jcprops.JPGSizeBytes;
return buffer;
}
BOOL CreateJpgBLP( StormBuffer rawData, StormBuffer &output, int quality, char const *, int width, int height, int bytespp, int alphaflag, int &maxmipmaps )
{
StormBuffer target[ 16 ];
StormBuffer scaled[ 16 ];
StormBuffer source;
source.buf = rawData.buf;
source.length = ( unsigned long )( width * height * 4 );
if ( bytespp < 4 )
{
source.buf = ( char * )Storm::MemAlloc( ( unsigned int )( width * height * 4 ) );
for ( int j = 0; j < width * height; j++ )
{
std::memcpy( source.buf + j * 4, rawData.buf + j*bytespp, ( size_t )bytespp );
source.buf[ j * 4 + 3 ] = '\xFF';
}
}
int truemipmaps = GetRequiredMipMaps( width, height );
BLPHeader blpHeader;
std::memcpy( blpHeader.ident, "BLP1", 4 );
blpHeader.compress = 0; // jpg compression
blpHeader.IsAlpha = ( uint32_t )alphaflag;
blpHeader.sizey = ( unsigned long )height;
blpHeader.sizex = ( unsigned long )width;
blpHeader.alphaEncoding = ( uint32_t )( !alphaflag ? 5 : 4 ); // BGR or BGRA
blpHeader.flags2 = 1;
memset( &blpHeader.poffs, 0, 16 * sizeof( long ) );
memset( &blpHeader.psize, 0, 16 * sizeof( long ) );
int xdimension = width;
int ydimension = height;
output.length = sizeof( BLPHeader ) + 4; // header + one int for jpg header size
for ( int i = 0; i < 16; i++ )
{
if ( i < maxmipmaps && xdimension > 0 && ydimension > 0 )
{
if ( i == 0 )
scaled[ 0 ] = source;
else // generate mipmaps
ScaleImage( ( unsigned char* )scaled[ i - 1 ].buf, xdimension * 2, ydimension * 2, xdimension, ydimension, 4, scaled[ i ] );
//if ( !ConvertToJpg( scaled[ i ], target[ i ], xdimension, ydimension, 4, quality, TRUE ) )
JPEG_CORE_PROPERTIES v17;
ijlInit( &v17 );
void * compressedimage;
int imglen = 0;
if ( compressedimage = Compress( scaled[ i ].buf, xdimension, ydimension, bytespp, imglen, quality ) )
{
target[ i ].buf = ( char * )compressedimage;
target[ i ].length = imglen;
}
else
{
for ( int j = 0; j <= i; j++ )
{ // cleanup
if ( bytespp < 4 || j > 0 )
scaled->Clear( );
if ( target[ j ].buf )
target[ j ].Clear( );
}
return FALSE;
}
blpHeader.poffs[ i ] = output.length;
blpHeader.psize[ i ] = target[ i ].length;
output.length += target[ i ].length;
}
else
{
if ( i < truemipmaps )
{
if ( i > 0 )
{
blpHeader.poffs[ i ] = blpHeader.poffs[ i - 1 ];
blpHeader.psize[ i ] = blpHeader.psize[ i - 1 ];
}
}
else
{
blpHeader.poffs[ i ] = 0;
blpHeader.psize[ i ] = 0;
}
}
xdimension = xdimension / 2;
ydimension = ydimension / 2;
}
maxmipmaps = min( truemipmaps, maxmipmaps );
output.buf = ( char * )Storm::MemAlloc( output.length );
std::memcpy( output.buf, &blpHeader, sizeof( BLPHeader ) );
memset( output.buf + sizeof( BLPHeader ), 0, 4 );
char* blp = output.buf + sizeof( BLPHeader ) + 4;
for ( int i = 0; i < 16; i++ )
{
if ( i < maxmipmaps && width > 0 && height > 0 )
{
std::memcpy( blp, target[ i ].buf, target[ i ].length );
if ( bytespp < 4 || i > 0 ) // cleanup
scaled[ i ].Clear( );
if ( target[ i ].buf )
target[ i ].Clear( );
blp += target[ i ].length;
}
width = width / 2;
height = height / 2;
}
return TRUE;
}
BOOL CreatePalettedBLP( StormBuffer rawData, StormBuffer &output, int colors, char const *, int width, int height, int bytespp, int alphaflag, int &maxmipmaps )
{
CQuantizer* q = new CQuantizer( ( unsigned int )colors, 8 );
q->ProcessImage( ( unsigned char* )rawData.buf, ( unsigned long )( width * height ), ( unsigned char )bytespp, 0x00 );
int truemipmaps = GetRequiredMipMaps( width, height );
BLPHeader blpHeader;
std::memcpy( blpHeader.ident, "BLP1", 4 );
blpHeader.compress = 1; // paletted
blpHeader.IsAlpha = 8;
blpHeader.sizey = ( unsigned long )height;
blpHeader.sizex = ( unsigned long )width;
blpHeader.alphaEncoding = 4; // BGR or BGRA
blpHeader.flags2 = 1;
memset( &blpHeader.poffs, 0, 16 * sizeof( long ) );
memset( &blpHeader.psize, 0, 16 * sizeof( long ) );
if ( !maxmipmaps )
maxmipmaps = truemipmaps;
output.length = sizeof( BLPHeader ) + sizeof( BGRAPix ) * 256; // header + palette
StormBuffer bufs[ 16 ];
int xdimension = width;
int ydimension = height;
for ( int i = 0; i < 16; i++ )
{
if ( i < maxmipmaps && xdimension > 0 && ydimension > 0 )
{
if ( i == 0 )
bufs[ 0 ] = rawData;
else // generate mipmaps
ScaleImage( ( unsigned char* )bufs[ i - 1 ].buf, xdimension * 2, ydimension * 2, xdimension, ydimension, bytespp, bufs[ i ] );
blpHeader.poffs[ i ] = output.length;
blpHeader.psize[ i ] = ( unsigned long )( xdimension * ydimension * 2 ); //(q->NeedsAlphaChannel() ? 2 : 1);
output.length += blpHeader.psize[ i ];
}
else
{
if ( i < truemipmaps )
{ // war3 requires at least 8 mipmaps for the alpha channel to work
if ( i > 0 )
{
blpHeader.poffs[ i ] = blpHeader.poffs[ i - 1 ];
blpHeader.psize[ i ] = blpHeader.psize[ i - 1 ];
}
}
else
{
blpHeader.poffs[ i ] = 0;
blpHeader.psize[ i ] = 0;
}
}
xdimension = xdimension / 2;
ydimension = ydimension / 2;
}
output.buf = ( char * )Storm::MemAlloc( output.length );
unsigned char* blpData = ( unsigned char* )output.buf;
std::memcpy( blpData, &blpHeader, sizeof( BLPHeader ) );
memset( blpData + sizeof( BLPHeader ), 0, sizeof( BGRAPix ) * 256 );
unsigned char* blp = blpData + sizeof( BLPHeader ) + sizeof( BGRAPix ) * 256;
BGRAPix *palette = ( BGRAPix* )( blpData + sizeof( BLPHeader ) );
q->SetColorTable( palette );
for ( int i = 0; i <= 16; i++ )
{
if ( i < maxmipmaps && width > 0 && height > 0 )
{
BGRAPix* raw = ( BGRAPix* )bufs[ i ].buf;
memset( blp, 0xFF, ( size_t )( width * height * 2 ) ); //(q->NeedsAlphaChannel() ? 2 : 1);
q->FloydSteinbergDither( ( unsigned char* )bufs[ i ].buf, width, height, ( unsigned char )bytespp, blp, palette );
if ( q->NeedsAlphaChannel( ) )
{
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++ )
{
unsigned char *z = blp + width * ( height - y - 1 ) + x + width * height;
BGRAPix *j = raw + width * y + x;
*( z ) = j->A;
}
}
}
if ( i > 0 )
bufs[ i ].Clear( ); // cleanup
blp += width * height * 2; //(q->NeedsAlphaChannel() ? 2 : 1);
}
width = width / 2;
height = height / 2;
}
delete q;
return TRUE;
}
BOOL TGA2Raw( StormBuffer input, StormBuffer &output, int &width, int &height, int &bpp, const char* filename )
{
TGAHeader* header = ( TGAHeader* )input.buf;
if ( header->colorMapType != 0 || header->imageType != 2 || header->width == 0 || header->height == 0 )
return FALSE;
if ( !IsPowerOfTwo( header->width ) || !IsPowerOfTwo( header->height ) )
return FALSE;
if ( header->bpp != 32 && header->bpp != 24 )
return FALSE;
bpp = 4;
if ( header->bpp < 4 )
bpp = 3;
width = header->width;
height = header->height;
output.length = ( unsigned long )( width*height*bpp );
output.buf = ( char * )Storm::MemAlloc( output.length );
std::memcpy( output.buf, input.buf + sizeof( TGAHeader ) + header->imageIDLength, output.length );
return TRUE;
}
BOOL RAW2Tga( StormBuffer input, StormBuffer &output, int width, int height, int bpp, const char* filename )
{
TGAHeader header;
memset( &header, 0, sizeof( TGAHeader ) );
header.imageType = 2;
header.width = width;
header.height = height;
header.bpp = bpp * 8;
header.imagedescriptor = bpp == 4 ? 8 : 0;
output.length = sizeof( TGAHeader ) + width * height * bpp;
output.buf = ( char * )Storm::MemAlloc( output.length );
std::memcpy( output.buf, &header, sizeof( TGAHeader ) );
std::memcpy( output.buf + sizeof( TGAHeader ), input.buf, output.length - sizeof( TGAHeader ) );
return TRUE;
}
BOOL BMP2Raw( StormBuffer input, StormBuffer &output, int &width, int &height, int &bpp, char const *filename )
{
BITMAPFILEHEADER *FileHeader = ( BITMAPFILEHEADER* )input.buf;
BITMAPINFOHEADER *InfoHeader = ( BITMAPINFOHEADER* )( FileHeader + 1 );
if ( FileHeader->bfType != 0x4D42 )
return FALSE;
if ( !IsPowerOfTwo( InfoHeader->biWidth ) || !IsPowerOfTwo( InfoHeader->biHeight ) )
return FALSE;
if ( InfoHeader->biBitCount != 32 && InfoHeader->biBitCount != 24 )
return FALSE;
bpp = 4;
if ( InfoHeader->biBitCount < 32 )
bpp = 3;
width = InfoHeader->biWidth;
height = InfoHeader->biHeight;
output.length = ( unsigned long )( width*height*bpp );
output.buf = ( char * )Storm::MemAlloc( output.length );
std::memcpy( output.buf, input.buf + FileHeader->bfOffBits, output.length );
if ( bpp == 4 ) // invert alpha
for ( int i = 0; i < width*height; i++ )
output.buf[ i*bpp + 3 ] = 0xFF - output.buf[ i*bpp + 3 ];
return TRUE;
}
#define _blp_swap_int16(x) (x)
#define _blp_swap_int32(x) (x)
void SwapBLPHeader( BLPHeader *header )
{
header->compress = ( unsigned long )_blp_swap_int32( header->compress );
header->IsAlpha = ( unsigned long )_blp_swap_int32( header->IsAlpha );
header->sizex = ( unsigned long )_blp_swap_int32( header->sizex );
header->sizey = ( unsigned long )_blp_swap_int32( header->sizey );
header->alphaEncoding = ( unsigned long )_blp_swap_int32( header->alphaEncoding );
header->flags2 = ( unsigned long )_blp_swap_int32( header->flags2 );
int i = 0;
for ( ; i < 16; i++ )
{
( header->poffs )[ i ] = ( unsigned long )_blp_swap_int32( ( header->poffs )[ i ] );
( header->psize )[ i ] = ( unsigned long )_blp_swap_int32( ( header->psize )[ i ] );
}
}
void textureInvertRBInPlace( RGBAPix *bufsrc, unsigned long srcsize )
{
for ( unsigned long i = 0; i < ( srcsize / 4 ); i++ )
{
unsigned char red = bufsrc[ i ].B;
bufsrc[ i ].B = bufsrc[ i ].R;
bufsrc[ i ].R = red;
}
}
void flip_vertically( unsigned char *pixels, const size_t width, const size_t height, const size_t bytes_per_pixel )
{
if ( !pixels )
return;
const size_t stride = width * bytes_per_pixel;
unsigned char *row = ( unsigned char * )malloc( stride );
if ( !row )
return;
unsigned char *low = pixels;
unsigned char *high = &pixels[ ( height - 1 ) * stride ];
for ( ; low < high; low += stride, high -= stride )
{
std::memcpy( row, low, stride );
std::memcpy( low, high, stride );
std::memcpy( high, row, stride );
}
free( row );
}
unsigned char * Scale_WithoutResize( unsigned char *pixels, const size_t width, const size_t height, const size_t newwidth, const size_t newheight, const size_t bytes_per_pixel )
{
if ( newwidth < width )
return pixels;
if ( newheight < height )
return pixels;
unsigned char * outimage = ( unsigned char * )Storm::MemAlloc( newwidth * newheight * bytes_per_pixel );
memset( outimage, 0, newwidth * newheight * bytes_per_pixel );
size_t y = 0;
for ( ; y < height; y++ )
{
unsigned char * offset1 = &pixels[ y * width * bytes_per_pixel ];
unsigned char * offset2 = &outimage[ y * newwidth * bytes_per_pixel ];
size_t copysize = width * bytes_per_pixel;
std::memcpy( offset2, offset1, copysize );
}
Storm::MemFree( pixels );
return outimage;
}
tBGRAPixel * blp1_convert_paletted_separated_alpha_BGRA( uint8_t* pSrc, tBGRAPixel* pInfos, unsigned int width, unsigned int height, BOOL invertAlpha )
{
tBGRAPixel* pBuffer = ( tBGRAPixel* )Storm::MemAlloc( width * height * sizeof( tBGRAPixel ) );
tBGRAPixel* pDst = pBuffer;
uint8_t* pIndices = pSrc;
uint8_t* pAlpha = pSrc + width * height;
for ( unsigned int y = 0; y < height; y++ )
{
for ( unsigned int x = 0; x < width; x++ )
{
*pDst = pInfos[ *pIndices ];
if ( invertAlpha )
pDst->a = ( uint8_t )( 0xFF - *pAlpha );
else
pDst->a = *pAlpha;
++pIndices;
++pAlpha;
++pDst;
}
}
flip_vertically( ( unsigned char* )pBuffer, width, height, 4 );
return pBuffer;
}
RGBAPix * blp1_convert_paletted_separated_alpha( uint8_t* pSrc, RGBAPix* pInfos, unsigned int width, unsigned int height, BOOL invertAlpha )
{
RGBAPix * outrgba = ( RGBAPix * )blp1_convert_paletted_separated_alpha_BGRA( pSrc, ( tBGRAPixel * )pInfos, width, height, invertAlpha );
return outrgba;
}
tBGRAPixel* blp1_convert_paletted_alpha_BGRA( uint8_t* pSrc, tBGRAPixel* pInfos, unsigned int width, unsigned int height )
{
tBGRAPixel* pBuffer = ( tBGRAPixel* )Storm::MemAlloc( width * height * sizeof( tBGRAPixel ) );
tBGRAPixel* pDst = pBuffer;
uint8_t* pIndices = pSrc;
for ( unsigned int y = 0; y < height; ++y )
{
for ( unsigned int x = 0; x < width; ++x )
{
*pDst = pInfos[ *pIndices ];
pDst->a = ( uint8_t )( 0xFF - pDst->a );
++pIndices;
++pDst;
}
}
return pBuffer;
}
RGBAPix* blp1_convert_paletted_alpha( uint8_t* pSrc, RGBAPix* pInfos, unsigned int width, unsigned int height )
{
RGBAPix * outrgba = ( RGBAPix * )blp1_convert_paletted_alpha_BGRA( pSrc, ( tBGRAPixel* )pInfos, width, height );
return outrgba;
}
tBGRAPixel* blp1_convert_paletted_no_alpha_BGRA( uint8_t* pSrc, tBGRAPixel* pInfos, unsigned int width, unsigned int height )
{
tBGRAPixel* pBuffer = ( tBGRAPixel * )Storm::MemAlloc( width * height * sizeof( tBGRAPixel ) );
tBGRAPixel* pDst = pBuffer;
uint8_t* pIndices = pSrc;
for ( unsigned int y = 0; y < height; ++y )
{
for ( unsigned int x = 0; x < width; ++x )
{
*pDst = pInfos[ *pIndices ];
pDst->a = 0xFF;
++pIndices;
++pDst;
}
}
flip_vertically( ( unsigned char* )pBuffer, width, height, 4 );
return pBuffer;
}
RGBAPix* blp1_convert_paletted_no_alpha( uint8_t* pSrc, RGBAPix* pInfos, unsigned int width, unsigned int height )
{
RGBAPix * outrgba = ( RGBAPix * )blp1_convert_paletted_no_alpha_BGRA( pSrc, ( tBGRAPixel* )pInfos, width, height );
return outrgba;
}
unsigned long Blp2Raw( StormBuffer input, StormBuffer &output, int &width, int &height, int &bpp, int &mipmaps, int & alphaflag, int & compresstype, int & pictype, char const *filename )
{
BLPHeader blph;
bpp = 4;
width = 0;
height = 0;
unsigned long curpos = 0;
unsigned long textureSize = 0;
if ( input.buf == NULL || input.length == NULL || input.length < sizeof( BLPHeader ) )
return 0;
std::memcpy( &blph, input.buf, sizeof( BLPHeader ) );
if ( memcmp( blph.ident, "BLP1", 4 ) != 0 )
return 0;
mipmaps = 0;
for ( int i = 0; i < 15; i++ )
{
if ( blph.poffs[ i ] > 0 )
{
mipmaps++;
}
}
alphaflag = ( int )blph.IsAlpha;
curpos += sizeof( BLPHeader );
textureSize = blph.sizex * blph.sizey * 4;
compresstype = ( int )blph.compress;
pictype = ( int )blph.alphaEncoding;
if ( blph.compress == 1 )
{
if ( input.length < curpos + 256 * 4 )
{
return 0;
}
RGBAPix Pal[ 256 ];
std::memcpy( Pal, input.buf + curpos, 256 * 4 );
curpos += 256 * 4;
int offset = ( int )blph.poffs[ 0 ];
int size = ( int )blph.psize[ 0 ];
if ( alphaflag > 0 && ( blph.alphaEncoding == 4 || blph.alphaEncoding == 3 ) )
{
if ( input.length < curpos + blph.sizex * blph.sizey * 2 )
return 0;
uint8_t* tdata = ( uint8_t * )Storm::MemAlloc( ( unsigned int )size );
std::memcpy( tdata, input.buf + offset, ( size_t )size );
RGBAPix *pic = blp1_convert_paletted_separated_alpha( ( uint8_t* )tdata, Pal, blph.sizex, blph.sizey, 0 );
Storm::MemFree( tdata );
output.length = textureSize;
output.buf = ( char * )Storm::MemAlloc( textureSize );
std::memcpy( output.buf, pic, textureSize );
Storm::MemFree( pic );
width = ( int )blph.sizex;
height = ( int )blph.sizey;
return textureSize;
}
else if ( alphaflag > 0 && blph.alphaEncoding == 5 )
{
if ( input.length < curpos + blph.sizex*blph.sizey )
return 0;
uint8_t* tdata = ( uint8_t * )Storm::MemAlloc( ( unsigned int )size );
std::memcpy( tdata, input.buf + offset, ( size_t )size );
RGBAPix *pic = blp1_convert_paletted_alpha( ( uint8_t* )tdata, Pal, blph.sizex, blph.sizey );
Storm::MemFree( tdata );
output.length = textureSize;
output.buf = ( char * )Storm::MemAlloc( textureSize );
std::memcpy( output.buf, pic, textureSize );
Storm::MemFree( pic );
width = ( int )blph.sizex;
height = ( int )blph.sizey;
return textureSize;
}
else
{
if ( input.length < curpos + blph.sizex * blph.sizey )
return 0;
uint8_t* tdata = ( uint8_t * )Storm::MemAlloc( ( unsigned int )size );
std::memcpy( tdata, input.buf + offset, ( size_t )size );
RGBAPix *pic = blp1_convert_paletted_no_alpha( ( uint8_t* )tdata, Pal, blph.sizex, blph.sizey );
Storm::MemFree( tdata );
output.length = textureSize;
output.buf = ( char * )Storm::MemAlloc( textureSize );
std::memcpy( output.buf, pic, textureSize );
Storm::MemFree( pic );
width = ( int )blph.sizex;
height = ( int )blph.sizey;
return textureSize;
}
}
// JPEG compressed
else if ( blph.compress == 0 )
{
unsigned long JPEGHeaderSize;
std::memcpy( &JPEGHeaderSize, input.buf + curpos, 4 );
JPEGHeaderSize = _blp_swap_int32( JPEGHeaderSize );
StormBuffer tempdata;
tempdata.length = blph.psize[ 0 ] + JPEGHeaderSize;
tempdata.buf = ( char * )Storm::MemAlloc( blph.psize[ 0 ] + JPEGHeaderSize );
std::memcpy( tempdata.buf, input.buf + curpos + 4, ( size_t )JPEGHeaderSize );
width = ( int )blph.sizex;
height = ( int )blph.sizey;
curpos = blph.poffs[ 0 ];
std::memcpy( ( tempdata.buf + JPEGHeaderSize ), input.buf + curpos, blph.psize[ 0 ] );
StormBuffer tmpout;
if ( !JPG2Raw( tempdata, tmpout, width, height, bpp, filename ) )
{
tmpout.Clear( );
tempdata.Clear( );
width = 0;
height = 0;
return 0;
}
tempdata.Clear( );
flip_vertically( ( unsigned char * )tmpout.buf, width, height, 4 );
// Output should be RGBA, BLPs use BGRA
//textureInvertRBInPlace( ( RGBAPix* )output.buf, output.length );
output = tmpout;
width = ( int )blph.sizex;
height = ( int )blph.sizey;
return textureSize;
}
return 0;
}
BOOL JPG2Raw( StormBuffer input, StormBuffer & output, int width, int height, int &bpp, char const *filename )
{
bpp = 4;
void * outdata;
if ( ( outdata = ReadImage( width, height, bpp, input.buf, input.length ) ) != NULL )
{
output.length = width * height * bpp;
output.buf = ( char * )outdata;
return TRUE;
}
//MessageBoxA( 0, "Convert error 1", " Success ! ", 0 );
return FALSE;
}
int ArrayXYtoId( int width, int x, int y )
{
return width * y + x;
} | 27.414579 | 186 | 0.605401 | UnrealKaraulov |
b31dfd9b9099f2aaf1c77dd643ac702de9b80669 | 2,599 | hpp | C++ | include/pcp/kdtree/linked_kdtree_node.hpp | Q-Minh/octree | 0c3fd5a791d660b37461daf968a68ffb1c80b965 | [
"BSL-1.0"
] | 2 | 2021-03-10T09:57:45.000Z | 2021-04-13T21:19:57.000Z | include/pcp/kdtree/linked_kdtree_node.hpp | Q-Minh/octree | 0c3fd5a791d660b37461daf968a68ffb1c80b965 | [
"BSL-1.0"
] | 22 | 2020-12-07T20:09:39.000Z | 2021-04-12T20:42:59.000Z | include/pcp/kdtree/linked_kdtree_node.hpp | Q-Minh/octree | 0c3fd5a791d660b37461daf968a68ffb1c80b965 | [
"BSL-1.0"
] | null | null | null | #ifndef PCP_KDTREE_KDTREE_NODE_HPP
#define PCP_KDTREE_KDTREE_NODE_HPP
/**
* @file
* @ingroup kd-tree
*/
#include <memory>
#include <vector>
namespace pcp {
/**
* @ingroup linked-kd-tree
* @brief
* A kdtree node at internal should only contain an element,
* while a leaf node may contain more than one element
* @tparam Element The element type
*/
template <class Element>
class basic_linked_kdtree_node_t
{
public:
using self_type = basic_linked_kdtree_node_t;
using self_type_ptr = std::unique_ptr<self_type>;
using element_type = Element;
using points_type = std::vector<element_type*>;
/**
* @brief Get the right child of the node
* @return Right child of the node
*/
self_type_ptr& left() { return left_; }
/**
* @brief Get the right child of the node
* @return Right child of the node
*/
self_type_ptr& right() { return right_; }
/**
* @brief Get the left child of the node (readonly)
* @return Left child of the node (readonly)
*/
self_type_ptr const& left() const { return left_; }
/**
* @brief Get the right child of the node (readonly)
* @return Right child of the node (readonly)
*/
self_type_ptr const& right() const { return right_; }
/**
* @brief Set the left child
* @param l the left child
*/
void set_left(self_type_ptr&& l) { left_ = std::move(l); }
/**
* @brief Set the right chikd
* @param r the right child
*/
void set_right(self_type_ptr&& r) { right_ = std::move(r); }
/**
* @brief Get the list of elements in the node
* internal node only contains 1 element
* Leaf node may contain more than 1 element
* @return List of elements in the node
*/
points_type& points() { return points_; }
/**
* @brief Get the list of elements in the node (readonly)
* internal node only contains 1 element
* Leaf node may contain more than 1 element
* @return List of elements in the node (readonly)
*/
points_type const& points() const { return points_; }
/**
* @brief Check if node is leaf
* @return True if node is leaf
*/
bool is_leaf() const { return left_ == nullptr && right_ == nullptr; }
/**
* @brief Check if leaf is internal
* @return True if leaf is internal
*/
bool is_internal() const { return !is_leaf(); }
private:
std::unique_ptr<self_type> left_;
std::unique_ptr<self_type> right_;
points_type points_;
};
} // namespace pcp
#endif // PCP_KDTREE_KDTREE_NODE_HPP | 25.480392 | 74 | 0.632551 | Q-Minh |
b3218bbc200b0178bfe069050d27c97a6d655801 | 457 | cpp | C++ | data/shaders/multi_material_mat.cpp | nczeroshift/nctoolkit | c9f0be533843d52036ec45200512ac54c1faeb11 | [
"MIT"
] | 2 | 2016-10-16T22:26:01.000Z | 2022-03-29T14:32:15.000Z | data/shaders/multi_material_mat.cpp | nczeroshift/nctoolkit | c9f0be533843d52036ec45200512ac54c1faeb11 | [
"MIT"
] | 1 | 2015-12-08T00:27:10.000Z | 2016-10-30T21:59:50.000Z | data/shaders/multi_material_mat.cpp | nczeroshift/nctoolkit | c9f0be533843d52036ec45200512ac54c1faeb11 | [
"MIT"
] | 2 | 2016-07-18T21:42:10.000Z | 2019-12-16T01:33:20.000Z |
#pragma vertex_shader_glx2
#include "vsh.cpp"
#include "material_vsh.cpp"
void main()
{
vec4 P = gl_Vertex;
vec3 N = gl_Normal;
material_vsh_prepare(gl_ModelViewMatrix,gl_NormalMatrix,P.xyz, N);
gl_Position = gl_ModelViewProjectionMatrix * P;
}
#pragma fragment_shader_glx2
#include "fsh.cpp"
#include "material.cpp"
void main()
{
vec3 color = material_diffuse_phong(lamp_mv_pos.xyz,vec2(0.0,0.0));
gl_FragColor = vec4(color, gphAlpha);
}
| 15.758621 | 68 | 0.743982 | nczeroshift |
b3242bc1d5789a307100bed1d2fcc24134356ab0 | 1,585 | cpp | C++ | Source Files/item.cpp | nicholaschiasson/d00m3d | ffca509901686bc5eb21baf15570989808f653a9 | [
"MIT"
] | null | null | null | Source Files/item.cpp | nicholaschiasson/d00m3d | ffca509901686bc5eb21baf15570989808f653a9 | [
"MIT"
] | null | null | null | Source Files/item.cpp | nicholaschiasson/d00m3d | ffca509901686bc5eb21baf15570989808f653a9 | [
"MIT"
] | null | null | null | #include "item.h"
Item::Item()
{
}
Item::Item(Ogre::SceneManager *sceneManager, Ogre::SceneNode* parentNode, PhysicsEngine &physicsEngine, Ogre::Vector3 location, Resource::RESOURCE_TYPE type, unsigned int parentID)
{
Initialize(sceneManager, parentNode, physicsEngine, location, type, parentID);
}
Item::~Item()
{
}
void Item::Update(const Ogre::FrameEvent &fe)
{
PhysicsEntity::Update(fe);
}
void Item::Initialize(Ogre::SceneManager *sceneManager, Ogre::SceneNode* parentNode, PhysicsEngine &physicsEngine, unsigned int parentID)
{
Initialize(sceneManager, parentNode, physicsEngine, Ogre::Vector3(0,0,0), Resource::NONE, parentID);
}
void Item::Initialize(Ogre::SceneManager *sceneManager, Ogre::SceneNode* parentNode, PhysicsEngine &physicsEngine, Ogre::Vector3 location, Resource::RESOURCE_TYPE type, unsigned int parentID)
{
PhysicsEntity::Initialize(sceneManager, parentNode, physicsEngine, parentID);
//setting our mass to 0
mass = 40.0f;
Ogre::Entity *itemEntity = sceneManager->createEntity("Cube");
itemEntity->setMaterialName("ItemMaterial");
sceneNode->attachObject(itemEntity);
scale(0.25f, 0.25f, 0.25f);
translate(location);
myType = type;
//TODO randomize?
value = 50;
}
void Item::Collide(const Ogre::FrameEvent &fe, PhysicsEntity *physicsEntity)
{
}
void Item::Damage(float damage)
{
// nope
}
int Item::getValue() const
{
return value;
}
Resource Item::collect(Entity* entity)
{
//we kill the item since we collected it.
kill();
return Resource(myType, 5.0f);
}
float Item::GetRadius()
{
return PhysicsEntity::GetRadius() * 25.0f;
} | 23.656716 | 191 | 0.744479 | nicholaschiasson |
b32674bd704a49e2ec0ac72dbbe4b797e1662a41 | 229 | cpp | C++ | URI/Ad-Hoc/1397.cpp | danielcunhaa/Competitive-Programming | 6868a8dfb8000fd10650a692c548a86272f19735 | [
"MIT"
] | 1 | 2021-04-03T11:17:33.000Z | 2021-04-03T11:17:33.000Z | URI/Ad-Hoc/1397.cpp | danielcunhaa/Competitive-Programming | 6868a8dfb8000fd10650a692c548a86272f19735 | [
"MIT"
] | null | null | null | URI/Ad-Hoc/1397.cpp | danielcunhaa/Competitive-Programming | 6868a8dfb8000fd10650a692c548a86272f19735 | [
"MIT"
] | 1 | 2020-07-24T15:27:46.000Z | 2020-07-24T15:27:46.000Z | #include <cstdio>
int main() {
int N, A, B;
int X, Y;
while(scanf("%d", &N) && N!=0) {
X = Y = 0;
while(N--) {
scanf("%d %d", &A, &B);
if(A != B) (A > B) ? ++X : ++Y;
}
printf("%d %d\n", X, Y);
}
return 0;
} | 13.470588 | 34 | 0.388646 | danielcunhaa |
b32bf360638ec756575175c2bcb10065c96c610c | 8,118 | cpp | C++ | vtStorAtaProtocol/Platform/Linux/ProtocolAtaPassThrough.cpp | virtium/vtStor | 069d3e1ddb1c5589826dfe59714a1479c4af8f51 | [
"Apache-2.0"
] | 3 | 2015-04-27T07:53:57.000Z | 2017-12-26T08:55:24.000Z | vtStorAtaProtocol/Platform/Linux/ProtocolAtaPassThrough.cpp | virtium/vtStor | 069d3e1ddb1c5589826dfe59714a1479c4af8f51 | [
"Apache-2.0"
] | 18 | 2015-04-08T21:44:45.000Z | 2016-03-09T23:44:51.000Z | vtStorAtaProtocol/Platform/Linux/ProtocolAtaPassThrough.cpp | virtium/vtStor | 069d3e1ddb1c5589826dfe59714a1479c4af8f51 | [
"Apache-2.0"
] | 19 | 2015-05-15T07:48:05.000Z | 2019-09-16T09:12:05.000Z | /*
<License>
Copyright 2016 Virtium Technology
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http ://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
</License>
*/
#include <assert.h>
#include <cstring>
#include <sys/ioctl.h>
#include "AtaProtocolEssense1.h"
#include "ProtocolAtaPassThrough.h"
#include "StorageUtility.h"
namespace vtStor
{
namespace Protocol
{
eErrorCode cAtaPassThrough::IssueCommand(const DeviceHandle& Handle, std::shared_ptr<const IBuffer> Essense, std::shared_ptr<IBuffer> DataBuffer)
{
eErrorCode errorCode = eErrorCode::None;
cBufferFormatter bufferFormatter = cBufferFormatter::Reader(Essense);
if (true == vtStor::CompareUUID(bufferFormatter.GetHeader().Format, cEssenseAta1::FormatType))
{
cEssenseAta1 essense = cEssenseAta1::Reader(Essense);
//! TODO: magic code 60
InitializePassThroughDirect(essense.GetCommandCharacteristics(), essense.GetTaskFileExt(), essense.GetTaskFile(), DataBuffer, 60);
errorCode = IssuePassThroughDirectCommand(Handle.Handle);
}
else
{
errorCode = eErrorCode::FormatNotSupported;
}
return(errorCode);
}
eErrorCode cAtaPassThrough::IssuePassThroughDirectCommand(const U32& FileDescriptor)
{
assert(INVALID_FILE_DESCRIPTOR != FileDescriptor);
U32 commandSuccessfulFlag = ioctl(FileDescriptor, SG_IO, &m_ATAPassThrough);
if (IOCTL_SG_IO_ERROR == commandSuccessfulFlag)
{
//! ERROR: IOCTL SG_IO was not successful
return(eErrorCode::Io);
}
return(eErrorCode::None);
}
void cAtaPassThrough::InitializePassThroughDirect(const StorageUtility::Ata::sCommandCharacteristic& CommandCharacteristics,
const StorageUtility::Ata::uTaskFileRegister& PreviousTaskFile,
const StorageUtility::Ata::uTaskFileRegister& CurrentTaskFile,
std::shared_ptr<IBuffer> DataBuffer,
U32 TimeoutValueInSeconds)
{
memset(&m_ATAPassThrough, 0, sizeof(m_ATAPassThrough));
//! TODO: Set up for Sense Data
m_ATAPassThrough.interface_id = static_cast<U32>(eSgAtaPassThough16::SgInterfaceId);
m_ATAPassThrough.mx_sb_len = static_cast<U8>(eSgAtaPassThough16::MaxSenseDataLength);
m_ATAPassThrough.cmd_len = static_cast<U8>(eSgAtaPassThough16::SgCdbLengh);
m_ATAPassThrough.dxfer_len = CommandCharacteristics.DataTransferLengthInBytes;
m_ATAPassThrough.timeout = TimeoutValueInSeconds;
if (nullptr != DataBuffer)
{
m_ATAPassThrough.dxferp = DataBuffer->ToDataBuffer();
}
InitializeFlags(CommandCharacteristics);
InitializeCommandDescBlock16Flags(CommandCharacteristics);
InitializeCommandDescBlock16Registers(PreviousTaskFile, CurrentTaskFile);
m_ATAPassThrough.cmdp = (U8*)&m_CommandDescBlock16;
}
void cAtaPassThrough::InitializeCommandDescBlock16Flags(const StorageUtility::Ata::sCommandCharacteristic& AtaCommandCharacteristic)
{
if (StorageUtility::Ata::eFieldFormatting::COMMAND_48_BIT == AtaCommandCharacteristic.FieldFormatting)
{
m_CommandDescBlock16.ExtendProtocol.Extend = SG_ATA_LBA48;
}
if (StorageUtility::Ata::eDataAccess::NONE != AtaCommandCharacteristic.DataAccess)
{
m_CommandDescBlock16.Param.TLength = static_cast<U8>(eTransferLenghValue::SpecInSectorCount);
m_CommandDescBlock16.Param.BytBlock = static_cast<U8>(eByteBlockBit::TransferSectorMode);
if (StorageUtility::Ata::eTransferMode::DMA_PROTOCOL == AtaCommandCharacteristic.TransferMode)
{
m_CommandDescBlock16.ExtendProtocol.Protocol = static_cast<U8>(eATAProtocolField::DMA);
}
else
{
if (StorageUtility::Ata::eDataAccess::WRITE_TO_DEVICE == AtaCommandCharacteristic.DataAccess)
{
m_CommandDescBlock16.ExtendProtocol.Protocol = static_cast<U8>(eATAProtocolField::PIO_Data_Out);
m_CommandDescBlock16.Param.TDir = static_cast<U8>(eTransferDirection::TransferToDevice);
}
else
{
//! Read to device
m_CommandDescBlock16.ExtendProtocol.Protocol = static_cast<U8>(eATAProtocolField::PIO_Data_In);
m_CommandDescBlock16.Param.TDir = static_cast<U8>(eTransferDirection::TransferFromDevice);
}
}
//! TODO: Support other protocols
}
else
{
m_CommandDescBlock16.ExtendProtocol.Protocol = static_cast<U8>(eATAProtocolField::NonData);
m_CommandDescBlock16.Param.CheckCondition = static_cast<U8>(eCheckCondition::CommonTerminate);
}
}
void cAtaPassThrough::InitializeFlags(const StorageUtility::Ata::sCommandCharacteristic& AtaCommandCharacteristic)
{
switch (AtaCommandCharacteristic.DataAccess)
{
case StorageUtility::Ata::eDataAccess::READ_FROM_DEVICE:
{
m_ATAPassThrough.dxfer_direction = SG_DXFER_FROM_DEV;
} break;
case StorageUtility::Ata::eDataAccess::WRITE_TO_DEVICE:
{
m_ATAPassThrough.dxfer_direction = SG_DXFER_TO_DEV;
} break;
case StorageUtility::Ata::eDataAccess::NONE:
{
m_ATAPassThrough.dxfer_direction = SG_DXFER_NONE;
m_ATAPassThrough.dxfer_len = 0;
} break;
default:
{
throw std::runtime_error("Attributes of the access was not supported\n");
} break;
}
}
void cAtaPassThrough::InitializeCommandDescBlock16Registers(const StorageUtility::Ata::uTaskFileRegister& PreviousTaskFile, const StorageUtility::Ata::uTaskFileRegister& CurrentTaskFile)
{
m_CommandDescBlock16.Opcode = static_cast<U8>(eSgAtaPassThough16::SgAtaPassThough);
m_CommandDescBlock16.LowDevice = CurrentTaskFile.InputRegister.Device;
m_CommandDescBlock16.LowCommand = CurrentTaskFile.InputRegister.Command;
m_CommandDescBlock16.LowFeature = CurrentTaskFile.InputRegister.Feature;
m_CommandDescBlock16.LowSectorCount = CurrentTaskFile.InputRegister.Count;
m_CommandDescBlock16.LowObLbaLow = CurrentTaskFile.InputRegister.LbaLow;
m_CommandDescBlock16.LowObLbaMid = CurrentTaskFile.InputRegister.LbaMid;
m_CommandDescBlock16.LowObLbaHigh = CurrentTaskFile.InputRegister.LbaHigh;
m_CommandDescBlock16.HighFeature = PreviousTaskFile.InputRegister.Feature;
m_CommandDescBlock16.HighSectorCount = PreviousTaskFile.InputRegister.Count;
m_CommandDescBlock16.HighObLbaLow = PreviousTaskFile.InputRegister.LbaLow;
m_CommandDescBlock16.HighObLbaMid = PreviousTaskFile.InputRegister.LbaMid;
m_CommandDescBlock16.HighObLbaHigh = PreviousTaskFile.InputRegister.LbaHigh;
}
}
}
| 43.881081 | 195 | 0.641907 | virtium |
b32dca93360bb7f208647226587b3c824edaaff4 | 2,056 | hh | C++ | include/mcnla/core/matrix/collection/base/matrix_collection_wrapper.hh | emfomy/mcnla | 9f9717f4d6449bbd467c186651856d6212035667 | [
"MIT"
] | null | null | null | include/mcnla/core/matrix/collection/base/matrix_collection_wrapper.hh | emfomy/mcnla | 9f9717f4d6449bbd467c186651856d6212035667 | [
"MIT"
] | null | null | null | include/mcnla/core/matrix/collection/base/matrix_collection_wrapper.hh | emfomy/mcnla | 9f9717f4d6449bbd467c186651856d6212035667 | [
"MIT"
] | null | null | null | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file include/mcnla/core/matrix/collection/base/matrix_collection_wrapper.hh
/// @brief The definition of matrix collection wrapper.
///
/// @author Mu Yang <<emfomy@gmail.com>>
///
#ifndef MCNLA_CORE_MATRIX_COLLECTION_BASE_MATRIX_COLLECTION_WRAPPER_HH_
#define MCNLA_CORE_MATRIX_COLLECTION_BASE_MATRIX_COLLECTION_WRAPPER_HH_
#include <mcnla/core/matrix/collection/def.hpp>
#include <tuple>
#include <mcnla/core/matrix/dense.hpp>
#include <mcnla/core/utility/crtp.hpp>
#include <mcnla/core/utility/traits.hpp>
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The MCNLA namespace.
//
namespace mcnla {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The matrix namespace.
//
namespace matrix {
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// The matrix collection wrapper.
///
/// @tparam _Derived The derived type.
///
template <class _Derived>
class MatrixCollectionWrapper {
private:
using MatrixType = MatrixT<_Derived>;
protected:
// Constructors
inline MatrixCollectionWrapper() noexcept = default;
public:
// Gets information
inline bool isEmpty() const noexcept;
inline index_t nrow() const noexcept;
inline index_t ncol() const noexcept;
inline index_t nmat() const noexcept;
inline index_t nelem() const noexcept;
inline std::tuple<index_t, index_t, index_t> sizes() const noexcept;
// Gets matrix
inline MatrixType operator()( const index_t idx ) noexcept;
inline const MatrixType operator()( const index_t idx ) const noexcept;
protected:
MCNLA_CRTP_DERIVED(_Derived)
};
} // namespace matrix
} // namespace mcnla
#endif // MCNLA_CORE_MATRIX_COLLECTION_BASE_MATRIX_COLLECTION_WRAPPER_HH_
| 29.797101 | 128 | 0.562257 | emfomy |
b32dd58447a592738e9f75dbd3ecccbb7f8f4609 | 3,679 | hpp | C++ | include/immediate_buckling_energy.hpp | liuwei792966953/stitch | 108e3dbd3410331c741c7cb166f93bbffa11b369 | [
"Zlib"
] | 1 | 2021-01-23T05:20:09.000Z | 2021-01-23T05:20:09.000Z | include/immediate_buckling_energy.hpp | liuwei792966953/stitch | 108e3dbd3410331c741c7cb166f93bbffa11b369 | [
"Zlib"
] | null | null | null | include/immediate_buckling_energy.hpp | liuwei792966953/stitch | 108e3dbd3410331c741c7cb166f93bbffa11b369 | [
"Zlib"
] | null | null | null |
#pragma once
#include "energy.hpp"
class ImmediateBucklingEnergy : public BaseEnergy
{
public:
ImmediateBucklingEnergy(double kb) : kb_(kb) {}
void precompute(const TriMesh& mesh) override;
void getForceAndHessian(const TriMesh& mesh, const VecXd& x,
VecXd& F,
SparseMatrixd& dFdx,
SparseMatrixd& dFdv) const override;
void getHessianPattern(const TriMesh& mesh, std::vector<SparseTripletd> &triplets) const override;
void perVertexCount(const TriMesh& mesh, std::vector<int>& counts) const override;
void update(const TriMesh& mesh, const VecXd& x, double dt, VecXd& dx) override;
protected:
const double kb_ = 1.0;
std::vector<std::pair<int,int>> pairs_;
std::vector<double> restLength_;
std::vector<double> triAreas_;
std::vector<bool> isCreased_;
bool across_stitches_ = false;
};
template <typename MeshT>
struct ImmediateBucklingModel
{
using ElementT = typename MeshT::Diamond;
static constexpr int dim = 1;
static int n_constraints() { return 1; }
static typename MeshT::Real ks(const MeshT& mesh, typename ElementT::iterator it) {
return mesh.bend_ks(it);
}
static typename MeshT::Real kd(const MeshT& mesh, typename ElementT::iterator it) {
return mesh.bend_kd(it);
}
template <typename DerivedA, typename DerivedB, typename DerivedC, typename DerivedD>
static void project(const Eigen::MatrixBase<DerivedA>& u0,
const Eigen::MatrixBase<DerivedA>& u1,
const Eigen::MatrixBase<DerivedA>& u2,
const Eigen::MatrixBase<DerivedA>& u3,
const Eigen::MatrixBase<DerivedB>& x0,
const Eigen::MatrixBase<DerivedB>& x1,
const Eigen::MatrixBase<DerivedB>& x3,
const Eigen::MatrixBase<DerivedB>& x4,
Eigen::MatrixBase<DerivedC>& C,
Eigen::MatrixBase<DerivedD>& dC0,
Eigen::MatrixBase<DerivedD>& dC1,
Eigen::MatrixBase<DerivedD>& dC2,
Eigen::MatrixBase<DerivedD>& dC3)
{
auto n = x1 - x0;
const auto L = (u1 - u0).norm(); // Rest length
const auto l = n.norm(); // Current length
dC0 = -n;
dC1 = n;
// Only resists compression
C[0] = l < L ? l - L : 0.0;
if (l > 1.0e-8) {
dC0 /= l;
dC1 /= l;
}
}
};
/*
template <typename MeshT>
struct IBM
{
using ElementT = typename MeshT::Edge;
static constexpr int dim = 1;
static int n_constraints() { return 1; }
static typename MeshT::Real ks(const MeshT& mesh, typename ElementT::iterator it) {
return mesh.bend_ks(it);
}
static typename MeshT::Real kd(const MeshT& mesh, typename ElementT::iterator it) {
return mesh.bend_kd(it);
}
template <typename DerivedA, typename DerivedB, typename DerivedC, typename DerivedD>
static void project(const Eigen::MatrixBase<DerivedA>& u0,
const Eigen::MatrixBase<DerivedA>& u1,
const Eigen::MatrixBase<DerivedB>& x0,
const Eigen::MatrixBase<DerivedB>& x1,
Eigen::MatrixBase<DerivedC>& C,
Eigen::MatrixBase<DerivedD>& dC0,
Eigen::MatrixBase<DerivedD>& dC1)
{
auto n = x1 - x0;
const auto L = (u1 - u0).norm(); // Rest length
const auto l = n.norm(); // Current length
dC0 = -n;
dC1 = n;
C[0] = l - L;
if (l > 1.0e-8) {
dC0 /= l;
dC1 /= l;
}
}
};
*/
| 27.661654 | 102 | 0.581952 | liuwei792966953 |
b32f38e8b222ae3d4f888fdcb5ebf711a62898a5 | 9,759 | cpp | C++ | LinaEditor/src/Panels/ECSPanel.cpp | moonantonio/LinaEngine | fe5a91a85c64dd0719656eb38e2fb37037bacfc1 | [
"MIT"
] | 10 | 2018-09-30T22:29:27.000Z | 2018-10-08T14:04:42.000Z | LinaEditor/src/Panels/ECSPanel.cpp | moonantonio/LinaEngine | fe5a91a85c64dd0719656eb38e2fb37037bacfc1 | [
"MIT"
] | 15 | 2018-10-02T22:14:17.000Z | 2018-10-12T08:01:36.000Z | LinaEditor/src/Panels/ECSPanel.cpp | moonantonio/LinaEngine | fe5a91a85c64dd0719656eb38e2fb37037bacfc1 | [
"MIT"
] | 1 | 2018-09-30T16:37:10.000Z | 2018-09-30T16:37:10.000Z | /*
This file is a part of: Lina Engine
https://github.com/inanevin/LinaEngine
Author: Inan Evin
http://www.inanevin.com
Copyright (c) [2018-2020] [Inan Evin]
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.
*/
#include "Panels/ECSPanel.hpp"
#include "Core/Application.hpp"
#include "Core/EditorApplication.hpp"
#include "Core/GUILayer.hpp"
#include "Core/InputBackend.hpp"
#include "ECS/Components/EntityDataComponent.hpp"
#include "ECS/Components/ModelRendererComponent.hpp"
#include "EventSystem/LevelEvents.hpp"
#include "Log/Log.hpp"
#include "Panels/LevelPanel.hpp"
#include "Rendering/Material.hpp"
#include "Panels/HeaderPanel.hpp"
#include "Rendering/Model.hpp"
#include "Utility/UtilityFunctions.hpp"
#include "Widgets/WidgetsUtility.hpp"
#include "Widgets/MenuButton.hpp"
#include "IconsFontAwesome5.h"
namespace Lina::Editor
{
using namespace ECS;
using namespace Lina;
std::map<Entity, bool> m_visibilityMouseMap;
bool m_isMouseDragging;
EntitiesPanel::~EntitiesPanel()
{
delete m_createMenuBarElement;
}
void EntitiesPanel::Initialize(const char* id, const char* icon)
{
EditorPanel::Initialize(id, icon);
Event::EventSystem::Get()->Connect<Event::ELevelInstalled, &EntitiesPanel::OnLevelInstall>(this);
Event::EventSystem::Get()->Connect<Event::EKeyCallback, &EntitiesPanel::OnKeyCallback>(this);
Event::EventSystem::Get()->Connect<EShortcut, &EntitiesPanel::OnShortcut>(this);
m_createMenuBarElement = new MenuBarElement("", "Create", nullptr, 0, MenuBarElementType::None, false);
auto& createElements = HeaderPanel::GetCreateEntityElements();
for (auto* elem : createElements)
m_createMenuBarElement->AddChild(elem);
}
void EntitiesPanel::DrawEntityNode(int id, ECS::Entity entity)
{
ECS::EntityDataComponent& data = ECS::Registry::Get()->get<ECS::EntityDataComponent>(entity);
const bool hasChildren = data.m_children.size() > 0;
const ImGuiTreeNodeFlags parent = ImGuiTreeNodeFlags_SpanFullWidth;
const ImGuiTreeNodeFlags leaf = ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth;
ImGuiTreeNodeFlags flags = hasChildren ? parent : leaf;
// Label as treenode.
ImGui::TableNextRow();
ImGui::TableNextColumn();
if (entity == m_selectedEntity)
flags |= ImGuiTreeNodeFlags_Selected;
const std::string treeLabel = data.m_name;
bool open = WidgetsUtility::TreeNode((void*)(intptr_t)entity, flags, treeLabel.c_str(), hasChildren);
// Select entity.
if (ImGui::IsItemClicked())
{
m_selectedEntity = entity;
Event::EventSystem::Get()->Trigger<EEntitySelected>(EEntitySelected{m_selectedEntity});
}
// Drag and drop.
if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_SourceAllowNullID))
{
ImGui::SetDragDropPayload(ECS_MOVEENTITY, &entity, sizeof(Entity));
// Display preview
ImGui::Text(data.m_name.c_str());
ImGui::EndDragDropSource();
}
if (ImGui::BeginDragDropTarget())
{
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(ECS_MOVEENTITY))
{
IM_ASSERT(payload->DataSize == sizeof(Entity));
ECS::Registry::Get()->AddChildToEntity(entity, *(Entity*)payload->Data);
}
ImGui::EndDragDropTarget();
}
// Visibility icon.
ImGui::TableNextColumn();
const char* visibilityIcon = data.GetIsEnabled() ? ICON_FA_EYE : ICON_FA_EYE_SLASH;
const float visibilityIconWidth = ImGui::CalcTextSize("AB").x;
ImVec4 textColor = ImGui::GetStyleColorVec4(ImGuiCol_Text);
textColor.w -= data.GetIsEnabled() ? 0.2f : 0.5f;
WidgetsUtility::TableAlignCenter(visibilityIconWidth);
ImGui::PushStyleColor(ImGuiCol_Text, ImGui::ColorConvertFloat4ToU32(textColor));
if (WidgetsUtility::IconButton(visibilityIcon))
{
ECS::Registry::Get()->SetEntityEnabled(entity, !data.GetIsEnabled());
}
// If the middle mouse is being dragged switch visibility for once, resetted when drag ends.
if (ImGui::IsItemHovered() && !m_visibilityMouseMap[entity] && m_isMouseDragging)
{
m_visibilityMouseMap[entity] = true;
ECS::Registry::Get()->SetEntityEnabled(entity, !data.GetIsEnabled());
}
ImGui::PopStyleColor();
// Draw children.
if (open && hasChildren)
{
for (auto child : data.m_children)
DrawEntityNode(0, child);
ImGui::TreePop();
}
}
void EntitiesPanel::OnShortcut(const EShortcut& event)
{
if (event.m_name.compare("duplicate") == 0)
{
if (m_selectedEntity != entt::null)
{
m_selectedEntity = ECS::Registry::Get()->CreateEntity(m_selectedEntity);
Event::EventSystem::Get()->Trigger<EEntitySelected>(EEntitySelected{m_selectedEntity});
}
}
else if (event.m_name.compare("create_empty") == 0)
{
auto ent = ECS::Registry::Get()->CreateEntity("Empty");
m_selectedEntity = ent;
Event::EventSystem::Get()->Trigger<EEntitySelected>(EEntitySelected{m_selectedEntity});
}
}
void EntitiesPanel::OnKeyCallback(const Event::EKeyCallback& ev)
{
if (ev.m_action == Input::InputAction::Pressed && ev.m_key == LINA_KEY_DELETE)
{
if (m_selectedEntity != entt::null)
{
Event::EventSystem::Get()->Trigger<EEntityUnselected>(EEntityUnselected{});
ECS::Registry::Get()->DestroyEntity(m_selectedEntity);
m_selectedEntity = entt::null;
}
}
}
void EntitiesPanel::OnLevelInstall(const Event::ELevelInstalled& ev)
{
Event::EventSystem::Get()->Trigger<EEntityUnselected>(EEntityUnselected{});
m_selectedEntity = entt::null;
}
void EntitiesPanel::Draw()
{
if (m_show)
{
Begin();
ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::GetStyleColorVec4(ImGuiCol_PopupBg));
ImGui::BeginChild("entities_child", ImVec2(0, -30), true);
static ImGuiTableFlags flags = ImGuiTableFlags_BordersV | ImGuiTableFlags_BordersOuterH | ImGuiTableFlags_RowBg;
if (ImGui::BeginTable("entitiesTable", 2, flags))
{
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoHide | ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("Enabled", ImGuiTableColumnFlags_WidthFixed, 40);
ImGui::TableHeadersRow();
auto singleView = ECS::Registry::Get()->view<ECS::EntityDataComponent>();
for (auto entity : singleView)
{
ECS::EntityDataComponent& data = ECS::Registry::Get()->get<ECS::EntityDataComponent>(entity);
if (data.m_parent == entt::null && data.m_name.compare(EDITOR_CAMERA_NAME) != 0)
DrawEntityNode(0, entity);
}
ImGui::EndTable();
}
// Switch visibility using mouse drag.
if (Input::InputEngineBackend::Get()->GetMouseButton(LINA_MOUSE_3))
m_isMouseDragging = true;
if (m_isMouseDragging && Input::InputEngineBackend::Get()->GetMouseButtonUp(LINA_MOUSE_3))
{
m_isMouseDragging = false;
m_visibilityMouseMap.clear();
}
if (!ImGui::IsItemHovered() && ImGui::IsWindowHovered() && ImGui::IsMouseClicked(ImGuiMouseButton_Left))
{
m_selectedEntity = entt::null;
Event::EventSystem::Get()->Trigger<EEntityUnselected>(EEntityUnselected());
}
WidgetsUtility::PushPopupStyle();
// Handle Right Click.
if (Application::Get()->GetActiveLevelExists() && ImGui::BeginPopupContextWindow())
{
m_createMenuBarElement->Draw();
ImGui::EndPopup();
}
WidgetsUtility::PopPopupStyle();
ImGui::EndChild();
ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.0f, 0.0f, 0.0f, 1.0f));
WidgetsUtility::HorizontalDivider();
ImGui::PopStyleColor();
ImGui::PopStyleColor();
End();
}
}
} // namespace Lina::Editor
| 38.270588 | 145 | 0.632134 | moonantonio |
b330b86f9a0166d2a0173a9b1db0c93bb3ff20ee | 100 | cpp | C++ | source/slang/slang-emit-context.cpp | KostasAndrianos/slang | 6cbc3929a54d37bd23cb5efa8e3320ba02f78b2f | [
"MIT"
] | null | null | null | source/slang/slang-emit-context.cpp | KostasAndrianos/slang | 6cbc3929a54d37bd23cb5efa8e3320ba02f78b2f | [
"MIT"
] | null | null | null | source/slang/slang-emit-context.cpp | KostasAndrianos/slang | 6cbc3929a54d37bd23cb5efa8e3320ba02f78b2f | [
"MIT"
] | null | null | null | // slang-emit-context.cpp
#include "slang-emit-context.h"
namespace Slang {
} // namespace Slang
| 12.5 | 31 | 0.71 | KostasAndrianos |
b332983e9973304dba040a625175348271461cc3 | 1,338 | cpp | C++ | osquery/config/parsers/kafka_topics.cpp | msekletar/osquery | beca5e68e97c5ff411b082fe871c69edcba1e641 | [
"BSD-3-Clause"
] | 7 | 2018-03-12T10:52:37.000Z | 2020-09-11T14:09:23.000Z | osquery/config/parsers/kafka_topics.cpp | msekletar/osquery | beca5e68e97c5ff411b082fe871c69edcba1e641 | [
"BSD-3-Clause"
] | 1 | 2021-03-20T05:24:15.000Z | 2021-03-20T05:24:15.000Z | osquery/config/parsers/kafka_topics.cpp | Acidburn0zzz/osquery | 1cedf8d57310b4ac3ae0a39fe33dce00699f4a3b | [
"BSD-3-Clause"
] | 4 | 2018-03-12T10:52:40.000Z | 2020-08-18T09:03:17.000Z | /*
* Copyright (c) 2014-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include <iostream>
#include <osquery/config.h>
#include "osquery/config/parsers/kafka_topics.h"
namespace osquery {
/// Root key to retrieve Kafka topic configurations.
const std::string kKafkaTopicParserRootKey("kafka_topics");
std::vector<std::string> KafkaTopicsConfigParserPlugin::keys() const {
return {kKafkaTopicParserRootKey};
}
Status KafkaTopicsConfigParserPlugin::setUp() {
data_.put_child(kKafkaTopicParserRootKey, boost::property_tree::ptree());
return Status(0, "OK");
}
Status KafkaTopicsConfigParserPlugin::update(const std::string& source,
const ParserConfig& config) {
if (config.count(kKafkaTopicParserRootKey) > 0) {
data_ = boost::property_tree::ptree();
data_.put_child(kKafkaTopicParserRootKey,
config.at(kKafkaTopicParserRootKey));
}
return Status(0, "OK");
}
REGISTER_INTERNAL(KafkaTopicsConfigParserPlugin,
"config_parser",
"kafka_topics");
} // namespace osquery
| 29.086957 | 79 | 0.697309 | msekletar |
b332b01fafcdbbfc42cf4d24c2dc090214a361e4 | 1,195 | cpp | C++ | src/luset_state_pkg/src/luset_state_package/node.cpp | nicholaspalomo/LUSETcontrol | 5576daf9551778804cd9dce8496a3f9ade6c4932 | [
"MIT"
] | null | null | null | src/luset_state_pkg/src/luset_state_package/node.cpp | nicholaspalomo/LUSETcontrol | 5576daf9551778804cd9dce8496a3f9ade6c4932 | [
"MIT"
] | null | null | null | src/luset_state_pkg/src/luset_state_package/node.cpp | nicholaspalomo/LUSETcontrol | 5576daf9551778804cd9dce8496a3f9ade6c4932 | [
"MIT"
] | null | null | null | /**
* @file node.cpp
* @author Nicholas José Palomo (npalomo@student.ethz.ch)
* @brief This is the source code for the /LusetState node. This node subscribes to messages coming from the Indel inco_32.so library (or from a simulation model - not yet implemented). See https://google.github.io/styleguide/cppguide.html for Google Style Guide for C++.
* @version 0.1
* @date 2020-02-24
*
* @copyright Copyright (c) 2020
*
*/
#include "LusetState.hpp"
int main(int argc, char** argv){
ros::init(argc, argv, "LusetState"); ///< Must call ros::init() before using any other part of the ROS system
ros::NodeHandle handle; ///< Instantiate a ROS node handle
ros::Rate loop_rate(10); ///< Set the loop_rate for processing the callbacks
lusetstatepubsubnamespace::LusetStatePubSub luset_state_pub_sub_obj(handle); ///< Instantiate LusetStateSubPub object
while(ros::ok()){ ///< Infinite loop until the user shuts down the rosmaster with Ctrl + C
ros::spinOnce(); ///< ros::spinOnce() processes our callbacks for a single thread.
loop_rate.sleep(); ///< Sleep for the remainder of the loop once all callbacks have been processed.
}
return 0;
} | 39.833333 | 271 | 0.703766 | nicholaspalomo |
b333454a393900b19684355abd32895647e8d03c | 430 | cpp | C++ | CodeForces/Complete/300-399/337A-Puzzles.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 36 | 2019-12-27T08:23:08.000Z | 2022-01-24T20:35:47.000Z | CodeForces/Complete/300-399/337A-Puzzles.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 10 | 2019-11-13T02:55:18.000Z | 2021-10-13T23:28:09.000Z | CodeForces/Complete/300-399/337A-Puzzles.cpp | Ashwanigupta9125/code-DS-ALGO | 49f6cf7d0c682da669db23619aef3f80697b352b | [
"MIT"
] | 53 | 2020-08-15T11:08:40.000Z | 2021-10-09T15:51:38.000Z | #include <cstdio>
#include <algorithm>
int main(){
int n(0), m(0); scanf("%d %d", &n, &m);
int *puzzles = new int[m];
for(int k = 0; k < m; k++){scanf("%d", puzzles + k);}
std::sort(puzzles, puzzles + m);
int output(10001);
for(int k = 0; k <= m - n; k++){
int diff = puzzles[k + n - 1] - puzzles[k];
if(diff < output){output = diff;}
}
printf("%d\n", output);
return 0;
}
| 22.631579 | 57 | 0.488372 | Ashwanigupta9125 |
b3363daafb6115a5f2b23466386b2da3fd977d7b | 14,586 | cpp | C++ | thirdparty/geogram/src/lib/exploragram/hexdom/extra_connectivity.cpp | AmericaMakes/OASIS-marcwang | 7aa10040251d7a1b807a773a45d123e1a52faac5 | [
"BSD-2-Clause"
] | 1 | 2021-03-07T14:47:09.000Z | 2021-03-07T14:47:09.000Z | thirdparty/geogram/src/lib/exploragram/hexdom/extra_connectivity.cpp | AmericaMakes/OASIS-marcwang | 7aa10040251d7a1b807a773a45d123e1a52faac5 | [
"BSD-2-Clause"
] | null | null | null | thirdparty/geogram/src/lib/exploragram/hexdom/extra_connectivity.cpp | AmericaMakes/OASIS-marcwang | 7aa10040251d7a1b807a773a45d123e1a52faac5 | [
"BSD-2-Clause"
] | 1 | 2021-03-07T00:24:57.000Z | 2021-03-07T00:24:57.000Z | /*
* OGF/Graphite: Geometry and Graphics Programming Library + Utilities
* Copyright (C) 2000-2015 INRIA - Project ALICE
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* If you modify this software, you should include a notice giving the
* name of the person performing the modification, the date of modification,
* and the reason for such modification.
*
* Contact for Graphite: Bruno Levy - Bruno.Levy@inria.fr
* Contact for this Plugin: Nicolas Ray - nicolas.ray@inria.fr
*
* Project ALICE
* LORIA, INRIA Lorraine,
* Campus Scientifique, BP 239
* 54506 VANDOEUVRE LES NANCY CEDEX
* FRANCE
*
* Note that the GNU General Public License does not permit incorporating
* the Software into proprietary programs.
*
* As an exception to the GPL, Graphite can be linked with the following
* (non-GPL) libraries:
* Qt, tetgen, SuperLU, WildMagic and CGAL
*/
#include <exploragram/hexdom/extra_connectivity.h>
#include <exploragram/hexdom/mesh_utils.h>
namespace GEO {
FacetsExtraConnectivity::FacetsExtraConnectivity(Mesh * p_m){
m = p_m;
reset();
}
void FacetsExtraConnectivity::reset(){
index_t nbc = m->facet_corners.nb();
c2f.resize(nbc);
c2c.resize(nbc);
v2c.resize(m->vertices.nb());
FOR(f, m->facets.nb()) FOR(fc, m->facets.nb_corners(f)){
index_t c = m->facets.corner(f, fc);
c2f[c] = f;
c2c[c] = c;
v2c[m->facets.vertex(f, fc)] = c;
}
FOR(f, m->facets.nb()) FOR(fc, m->facets.nb_corners(f)){
index_t c = m->facets.corner(f, fc);
c2c[c] = v2c[m->facets.vertex(f, fc)];
v2c[m->facets.vertex(f, fc)] = c;
}
}
index_t FacetsExtraConnectivity::org(index_t corner_id){ return m->facet_corners.vertex(corner_id); }
index_t FacetsExtraConnectivity::dest(index_t corner_id){ return m->facet_corners.vertex(next(corner_id)); }
index_t FacetsExtraConnectivity::opposite(index_t corner_id){
index_t cir = corner_id;
index_t result = NOT_AN_ID; // not found
do {
index_t candidate = prev(cir);
if ((org(candidate) == dest(corner_id)) && (dest(candidate) == org(corner_id))){
if (result == NOT_AN_ID) result = candidate;
else return NOT_AN_ID; // found more than one
}
if (cir != corner_id && dest(corner_id) == dest(cir))
return NOT_AN_ID; // the edge is non manifold
cir = c2c[cir];
} while (cir != corner_id);
return result;
}
index_t FacetsExtraConnectivity::next_around_vertex(index_t cir) { return opposite(prev(cir)); }
index_t FacetsExtraConnectivity::facet(index_t corner_id) { return c2f[corner_id]; }
index_t FacetsExtraConnectivity::local_id(index_t corner_id) { return corner_id - m->facets.corners_begin(c2f[corner_id]); }
index_t FacetsExtraConnectivity::next(index_t corner_id) {
index_t fc = local_id(corner_id);
index_t offset = corner_id - fc;
return offset + next_mod(fc, m->facets.nb_corners(c2f[corner_id]));
}
index_t FacetsExtraConnectivity::prev(index_t corner_id) {
index_t fc = local_id(corner_id);
index_t offset = corner_id - fc;
return offset + prev_mod(fc, m->facets.nb_corners(c2f[corner_id]));
}
vec3 FacetsExtraConnectivity::geom(index_t corner_id){
return X(m)[dest(corner_id)] - X(m)[org(corner_id)];
}
FacetsExtraConnectivityWithInvalidFacets::FacetsExtraConnectivityWithInvalidFacets(Mesh * p_m) {
m = p_m;
facet_is_valid.bind(m->facets.attributes(), "is_valid");
FOR(f, m->facets.nb()) facet_is_valid[f] = true;
reset();
}
void FacetsExtraConnectivityWithInvalidFacets::reset() {
//plop(m->facets.nb());
index_t nbc = m->facet_corners.nb();
c2f.resize(nbc,NOT_AN_ID);
c2c.resize(nbc, NOT_AN_ID);
v2c.resize(m->vertices.nb(), NOT_AN_ID);
FOR(f, m->facets.nb()) FOR(fc, m->facets.nb_corners(f)) {
index_t c = m->facets.corner(f, fc);
if (facet_is_valid[f]) { // everything is NOT_AN_ID for invalid facet and associated corner
c2f[c] = f;
c2c[c] = c;
v2c[m->facets.vertex(f, fc)] = c;
}
}
FOR(f, m->facets.nb()) {
if (!facet_is_valid[f]) continue;
FOR(fc, m->facets.nb_corners(f)) {
index_t c = m->facets.corner(f, fc);
c2c[c] = v2c[m->facets.vertex(f, fc)];
v2c[m->facets.vertex(f, fc)] = c;
}
}
}
index_t FacetsExtraConnectivityWithInvalidFacets::org(index_t corner_id) { return m->facet_corners.vertex(corner_id); }
index_t FacetsExtraConnectivityWithInvalidFacets::dest(index_t corner_id) { return m->facet_corners.vertex(next(corner_id)); }
index_t FacetsExtraConnectivityWithInvalidFacets::opposite(index_t corner_id) {
index_t cir = corner_id;
index_t result = NOT_AN_ID; // not found
do {
index_t candidate = prev(cir);
if ((org(candidate) == dest(corner_id)) && (dest(candidate) == org(corner_id))) {
if (result == NOT_AN_ID) result = candidate;
else return NOT_AN_ID; // found more than one
}
if (cir != corner_id && dest(corner_id) == dest(cir))
return NOT_AN_ID; // the edge is non manifold
cir = c2c[cir];
} while (cir != corner_id);
return result;
}
//index_t FacetsExtraConnectivityWithInvalidFacets::next_around_vertex(index_t cir) { return opposite(prev(cir)); }
index_t FacetsExtraConnectivityWithInvalidFacets::facet(index_t corner_id) { return c2f[corner_id]; }
index_t FacetsExtraConnectivityWithInvalidFacets::local_id(index_t corner_id) { return corner_id - m->facets.corners_begin(c2f[corner_id]); }
index_t FacetsExtraConnectivityWithInvalidFacets::next(index_t corner_id) {
index_t fc = local_id(corner_id);
index_t offset = corner_id - fc;
return offset + next_mod(fc, m->facets.nb_corners(c2f[corner_id]));
}
index_t FacetsExtraConnectivityWithInvalidFacets::prev(index_t corner_id) {
index_t fc = local_id(corner_id);
index_t offset = corner_id - fc;
return offset + prev_mod(fc, m->facets.nb_corners(c2f[corner_id]));
}
vec3 FacetsExtraConnectivityWithInvalidFacets::geom(index_t corner_id) {
return X(m)[dest(corner_id)] - X(m)[org(corner_id)];
}
void halfedge_manip_example(Mesh* m){
FacetsExtraConnectivity fec(m);
FOR(c, m->facet_corners.nb()){// we can directly loop over each halfedges
// turning around a facet
index_t cir = c;
do {
cir = fec.next(cir);
} while (cir != c);
//iterate on vertex incident
cir = c;
do {
cir = fec.c2c[cir];
} while (cir != c);
//turning around a manifold vertex
cir = c;
do {
cir = fec.next_around_vertex(cir);
} while (cir != c && cir != NOT_AN_ID);
}
}
void create_facet_adjacence(Mesh* m, bool has_border){
FacetsExtraConnectivity qfec(m);
FOR(h, m->facet_corners.nb()){
index_t opp = qfec.opposite(h);
if (!has_border && opp == NOT_AN_ID) GEO::Logger::out("HexDom") << "PANIC MODE, INPUT IS NON MANIFOLD !!! --- check if the surface has border" << std::endl;
else {
m->facets.set_adjacent(qfec.facet(h), qfec.local_id(h), qfec.facet(opp));
m->facets.set_adjacent(qfec.facet(opp), qfec.local_id(opp), qfec.facet(h));
}
}
}
void cell_edges_in_RCS(Mesh* m, vector<index_t>& offset_from_org, vector<index_t>& dest){
geo_assert(m->cells.are_simplices());
dest.clear();
offset_from_org.clear();
offset_from_org.reserve(m->vertices.nb());
vector<index_t> v2cc(m->vertices.nb(), NOT_AN_ID); // v2cc maps vertices to cell corner
vector<index_t> next(4 * m->cells.nb(), NOT_AN_ID); // next chains cell corners
FOR(c, m->cells.nb()) FOR(cv, 4){
index_t v = m->cells.vertex(c, cv);
next[4 * c + cv] = v2cc[v];
v2cc[v] = 4 * c + cv;
}
FOR(v, m->vertices.nb()){
offset_from_org.push_back(dest.size());
for (index_t i = v2cc[v]; i != NOT_AN_ID; i = next[i])
FOR(lc, 4) if (i % 4 != lc)
dest.push_back(m->cells.vertex(i / 4, lc));
std::sort(dest.begin() + int(offset_from_org.back()), dest.end());
vector<index_t>::iterator last = std::unique(dest.begin() + int(offset_from_org.back()), dest.end());
dest.resize(size_t(last - dest.begin()));
}
offset_from_org.push_back(dest.size());
}
void compute_tet_edge_graph(Mesh* m,vector<index_t> & v2e,bool store_both_directions){
geo_assert(m->cells.are_simplices());
m->edges.clear();
v2e.resize(m->vertices.nb());
//Attribute<index_t> v2e(m->vertices.attributes(), "v2e");
vector<index_t> adj_;
vector<index_t> adj_off_;
adj_off_.reserve(m->vertices.nb() + 1);
vector<index_t> v2c(m->vertices.nb(), NOT_AN_ID);
vector<index_t> next(4 * m->cells.nb(), NOT_AN_ID);
FOR(c, m->cells.nb()) FOR(cv, 4){
index_t v = m->cells.vertex(c, cv);
next[4 * c + cv] = v2c[v];
v2c[v] = 4 * c + cv;
}
FOR(v, m->vertices.nb()){
adj_off_.push_back(adj_.size());
for (index_t i = v2c[v]; i != NOT_AN_ID; i = next[i]) FOR(lc, 4) if (i % 4 != lc){
index_t nv = m->cells.vertex(i / 4, lc);
if (nv>v || store_both_directions) adj_.push_back(nv);
}
std::sort(adj_.begin() + int(adj_off_.back()), adj_.end());
vector<index_t>::iterator last = std::unique(adj_.begin() + int(adj_off_.back()), adj_.end());
adj_.resize(size_t(last - adj_.begin()));
}
adj_off_.push_back(adj_.size());
index_t offe = m->edges.create_edges(adj_.size());
FOR(v, m->vertices.nb()){
v2e[v] = adj_off_[v];
for (index_t e = adj_off_[v]; e < adj_off_[v + 1]; e++){
m->edges.set_vertex(offe + e, 0, v);
m->edges.set_vertex(offe + e, 1, adj_[e]);
}
}
}
void restore_v2e(Mesh* m, vector<index_t>& v2e) {
v2e.resize(m->vertices.nb());
FOR(v, m->vertices.nb())v2e[v] = NOT_AN_ID;
index_t lastv = 0;
FOR(e, m->edges.nb()) {
index_t org = m->edges.vertex(e, 0);
while (lastv <= org) { v2e[lastv] = e; lastv++; }
}
while (lastv < m->vertices.nb()) { v2e[lastv] = m->edges.nb(); lastv++; }
}
/**
* check that v2f[v] gives all facets that
* are adjacent to v
* are not to be killed
*/
bool v2f_is_valid(Mesh* m, vector<vector<index_t> >& v2f, vector<index_t> &to_kill) {
vector<vector<bool> > is_ref(m->vertices.nb());
FOR(v, m->vertices.nb()) is_ref[v].resize(v2f[v].size(), false);
// check that all facets are referenced
FOR(f, m->facets.nb()) if (!to_kill[f])
FOR(lc, m->facets.nb_corners(f)) {
index_t v = m->facets.vertex(f, lc);
bool f_is_ref = false;
FOR(i, v2f[v].size()) if (v2f[v][i] == f) {
is_ref[v][i] = true;
f_is_ref = true;
}
if (!f_is_ref) {
GEO::Logger::out("HexDom") << "facet " << f << " is not referenced in vertex " << v << " !!!" << std::endl;
return false;
}
}
// check that no extra facet is referenced
FOR(v, m->vertices.nb()) FOR(i, v2f[v].size()) if (!is_ref[v][i]) {
GEO::Logger::out("HexDom") << "one facet of v2f does not exist!!!" << std::endl;
return false;
}
return true;
}
}
| 41.913793 | 184 | 0.517894 | AmericaMakes |
b337a09cf7460124080e9068428e0e9e05783842 | 53,736 | cpp | C++ | tests/integrationtests/db/SqliteDatabaseIntegrationTest.cpp | commshare/easyhttpcpp | 757ec75679c1cbc5f04c81a30133f4bcd3e780f4 | [
"MIT"
] | null | null | null | tests/integrationtests/db/SqliteDatabaseIntegrationTest.cpp | commshare/easyhttpcpp | 757ec75679c1cbc5f04c81a30133f4bcd3e780f4 | [
"MIT"
] | null | null | null | tests/integrationtests/db/SqliteDatabaseIntegrationTest.cpp | commshare/easyhttpcpp | 757ec75679c1cbc5f04c81a30133f4bcd3e780f4 | [
"MIT"
] | null | null | null | /*
* Copyright 2017 Sony Corporation
*/
#include "gtest/gtest.h"
#include <stdint.h>
#include "Poco/Path.h"
#include "Poco/Data/SQLite/Connector.h"
#include "easyhttpcpp/common/FileUtil.h"
#include "easyhttpcpp/common/StringUtil.h"
#include "easyhttpcpp/db/AutoSqliteTransaction.h"
#include "easyhttpcpp/db/SqlException.h"
#include "easyhttpcpp/db/SqliteQueryBuilder.h"
#include "EasyHttpCppAssertions.h"
#include "PartialMockSqliteOpenHelper.h"
#include "TestLogger.h"
#include "TestPreferences.h"
#include "SqliteDatabaseIntegrationTestConstants.h"
#include "SqliteDatabaseTestUtil.h"
using easyhttpcpp::common::FileUtil;
using easyhttpcpp::common::StringUtil;
using easyhttpcpp::testutil::PartialMockSqliteOpenHelper;
using easyhttpcpp::testutil::TestPreferences;
namespace easyhttpcpp {
namespace db {
namespace test {
namespace {
const std::string DatabaseDirString = SqliteDatabaseIntegrationTestConstants::DatabaseDir;
const std::string DatabaseFileName = SqliteDatabaseIntegrationTestConstants::DatabaseFileName;
const std::string DatabaseTableName = SqliteDatabaseIntegrationTestConstants::DatabaseTableName;
} /* namespace */
#define ELEMENT_NUM(st) (sizeof(st) / (sizeof st[0]))
class SqliteDatabaseIntegrationTest : public testing::Test {
protected:
static void SetUpTestCase()
{
// initialize test preferences with QA profile
TestPreferences::getInstance().initialize(TestPreferences::ProfileQA);
Poco::Path databaseDir(DatabaseDirString);
FileUtil::createDirsIfAbsent(Poco::File(databaseDir));
}
void TearDown()
{
EASYHTTPCPP_TESTLOG_TEARDOWN_START();
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
m_pTestUtil = NULL;
FileUtil::removeFileIfPresent(databaseFilePath);
}
void createDefaultDatabaseTable()
{
// create table and insert data
// table is as below
// |Id | Name | Address | Age |
// | 1 | "Bart Simpson" | "Springfield" | 12 |
// | 2 | "Lisa Simpson" | "Springfield" | 10 |
//
std::string columnString = "Id INTEGER PRIMARY KEY AUTOINCREMENT, \
Name VARCHAR(30) UNIQUE, Address VARCHAR, Age INTEGER(3)";
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Bart Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 12);
Poco::AutoPtr<ContentValues> pContentValues2 = new ContentValues();
pContentValues2->put("Name", "Lisa Simpson");
pContentValues2->put("Address", "Springfield");
pContentValues2->put("Age", 10);
//push back pContentValues and pContentValues2 to valuesVec
std::vector<ContentValues*> valuesVec;
valuesVec.push_back(pContentValues);
valuesVec.push_back(pContentValues2);
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
m_pTestUtil = new SqliteDatabaseTestUtil();
m_pTestUtil->createAndOpenDatabase(databaseFilePath, 1);
m_pTestUtil->createTable(DatabaseTableName, columnString);
m_pTestUtil->insertData(DatabaseTableName, valuesVec);
}
void createDefaultDatabaseTableWithoutData()
{
// create table and insert data
// table is as below
std::string columnString = "Id INTEGER PRIMARY KEY AUTOINCREMENT, \
Name VARCHAR(30) UNIQUE, Address VARCHAR, Age INTEGER(3)";
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
m_pTestUtil = new SqliteDatabaseTestUtil();
m_pTestUtil->createAndOpenDatabase(databaseFilePath, 1);
m_pTestUtil->createTable(DatabaseTableName, columnString);
}
SqliteCursor::Ptr queryDatabase(const std::string& tableName, const std::vector<std::string>* columns)
{
return m_pTestUtil->queryDatabase(tableName, columns, NULL, NULL);
}
struct RowElement {
int m_id;
char m_name[20];
char m_address[20];
int m_age;
};
bool databaseHasColumns(SqliteCursor::Ptr pCursor, size_t expectedColumnCount,
std::vector<std::string>& expectedColumnNames)
{
bool ret = false;
if (pCursor->getColumnCount() != expectedColumnCount) {
return ret;
}
std::vector<std::string> columnNames = pCursor->getColumnNames();
for (size_t i = 0; i < expectedColumnCount; i++) {
if (columnNames.at(i) != expectedColumnNames.at(i)) {
break;
}
ret = true;
}
return ret;
}
bool databaseHasRow(SqliteCursor::Ptr pCursor, RowElement& expectedRowElement)
{
bool ret = false;
size_t idIndex = SIZE_MAX;
size_t ageIndex = SIZE_MAX;
size_t nameIndex = SIZE_MAX;
size_t addressIndex = SIZE_MAX;
// column count
size_t columnCount = pCursor->getColumnCount();
// column names
std::vector<std::string> columnNames = pCursor->getColumnNames();
for (size_t i = 0; i < columnCount; i++) {
if (columnNames.at(i) == "Id") {
idIndex = i;
} else if (columnNames.at(i) == "Age") {
ageIndex = i;
} else if (columnNames.at(i) == "Name") {
nameIndex = i;
} else if (columnNames.at(i) == "Address") {
addressIndex = i;
}
}
if (idIndex == SIZE_MAX && ageIndex == SIZE_MAX && nameIndex == SIZE_MAX && addressIndex == SIZE_MAX) {
return ret;
}
if (!pCursor->moveToFirst()) {
return ret;
}
bool idExist = false;
bool ageExist = false;
bool nameExist = false;
bool addressExist = false;
do {
idExist = false;
ageExist = false;
nameExist = false;
addressExist = false;
if (idIndex == SIZE_MAX || pCursor->getInt(idIndex) == expectedRowElement.m_id) {
idExist = true;
}
if (ageIndex == SIZE_MAX || pCursor->getInt(ageIndex) == expectedRowElement.m_age) {
ageExist = true;
}
if (nameIndex == SIZE_MAX || pCursor->getString(nameIndex) == expectedRowElement.m_name) {
nameExist = true;
}
if (addressIndex == SIZE_MAX || pCursor->getString(addressIndex) == expectedRowElement.m_address) {
addressExist = true;
}
if (idExist & ageExist & nameExist & addressExist) {
ret = true;
break;
}
} while (pCursor->moveToNext());
return ret;
}
SqliteDatabaseTestUtil::Ptr m_pTestUtil;
};
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsQueryResult)
{
// Given: create database
createDefaultDatabaseTable();
// When: query Age, and Name
std::vector<std::string> columns;
columns.push_back("Id");
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
SqliteCursor::Ptr pCursor = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, false);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, rawQuery_ReturnsQueryResult)
{
// Given: create database
createDefaultDatabaseTable();
// When: buidQueryString and call rawQuery
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
std::string queryString = SqliteQueryBuilder::buildQueryString(DatabaseTableName, &columns, NULL, NULL, NULL, NULL,
NULL, false);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
SqliteCursor::Ptr pCursor = pDb->rawQuery(queryString, NULL);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, insert_Succeeds)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->insert(DatabaseTableName, *pContentValues);
pDb->setTransactionSuccessful();
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
{3, "Homer Simpson", "Springfield", 38}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, replace_Succeeds_WhenPrimaryKeyConflicts)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 99);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->replace(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{3, "Lisa Simpson", "Springfield", 99},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, replace_Succeeds_WhenPrimaryKeyDoesNotConflict)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->replace(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
{3, "Homer Simpson", "Springfield", 38},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, delete_Succeeds_WhenWhereClauseMatches)
{
// Given: create database
createDefaultDatabaseTable();
// When: delete data
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 10";
size_t id = pDb->deleteRows(DatabaseTableName, &whereClause, NULL);
pDb->setTransactionSuccessful();
EXPECT_EQ(1, id);
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, delete_DoNothing_WhenWhereClauseDoesNotMatch)
{
// Given: create database
createDefaultDatabaseTable();
// When: delete data
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 33";
size_t id = pDb->deleteRows(DatabaseTableName, &whereClause, NULL);
pDb->setTransactionSuccessful();
EXPECT_EQ(0, id);
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, delete_Succeeds_WhenWhereClauseMatchesToMultiRaw)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Nobi Nobita");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 10);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
pDb->endTransaction();
// When: delete data
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 10";
size_t id = pDb->deleteRows(DatabaseTableName, &whereClause, NULL);
pDb->setTransactionSuccessful();
EXPECT_EQ(2, id);
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, update_Succeeds_WhenWhereClauseMatches)
{
// Given: create database
createDefaultDatabaseTable();
// When: update data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Maggie Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 1);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 10";
size_t id = pDb->update(DatabaseTableName, *(pContentValues.get()), &whereClause, NULL);
pDb->setTransactionSuccessful();
EXPECT_EQ(1, id);
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Maggie Simpson", "Springfield", 1}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, update_Succeeds_WhenWhereClauseHasMultiConditions)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Nobi Nobita");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 10);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
pDb->endTransaction();
// When: update data
pContentValues->put("Name", "Maggie Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 1);
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 10 AND Address = 'Tokyo'";
size_t id = pDb->update(DatabaseTableName, *(pContentValues.get()), &whereClause, NULL);
pDb->setTransactionSuccessful();
EXPECT_EQ(1, id);
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
{3, "Maggie Simpson", "Springfield", 1}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{3, "Nobi Nobita", "Tokyo", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, update_throwsSqlExecutionException_WhenWhereClauseMatchesToMultiRaw)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Nobi Nobita");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 10);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
pDb->endTransaction();
// When: update data
pContentValues->put("Name", "Maggie Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 1);
AutoSqliteTransaction autoTransaction(pDb);
std::string whereClause = "Age = 10";
size_t id = 0;
EASYHTTPCPP_ASSERT_THROW_WITH_CAUSE(id = pDb->update(DatabaseTableName, *(pContentValues.get()), &whereClause, NULL),
SqlExecutionException, 100202);
pDb->setTransactionSuccessful();
EXPECT_EQ(0, id);
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
{3, "Nobi Nobita", "Tokyo", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Maggie Simpson", "Springfield", 1},
{3, "Maggie Simpson", "Springfield", 1}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, beginTransaction_throwsSqlIllegalStateException_AfterCloseDatabase)
{
// Given: create database
createDefaultDatabaseTable();
// When: close database
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->close();
// Then: Access to SqliteDatabase throws Exception
EASYHTTPCPP_EXPECT_THROW(pDb->beginTransaction(), SqlIllegalStateException, 100201);
}
TEST_F(SqliteDatabaseIntegrationTest, query_Succeeds_WhenReopenDatabase)
{
// Given: create database
createDefaultDatabaseTable();
// When: close SqliteDatabase
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->close();
EASYHTTPCPP_EXPECT_THROW(pDb->beginTransaction(), SqlIllegalStateException, 100201);
// When: reopen and insert data
pDb->reopen();
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, endTransaction_RollbacksData_WhenWithoutCallSetTransactionSuccessful)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
// call SqliteDatabase::endTransaction() without call setTransactionSuccessful()
pDb->endTransaction();
// Then: verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{3, "Homer Simpson", "Springfield", 38}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsQueryResult_WhenSelectionArgsExists)
{
// Given: create database
createDefaultDatabaseTable();
// When: query Age, and Name, with SelectionArgs "Age = 10"
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
std::string selection = "Age = ?";
std::vector<std::string> selectionArgs;
selectionArgs.push_back("10");
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
SqliteCursor::Ptr pCursor = pDb->query(DatabaseTableName, &columns, &selection, &selectionArgs, NULL, NULL, NULL,
NULL, false);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsQueryResult_WhenSelectionArgsExistsMulti)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *pContentValues);
pDb->setTransactionSuccessful();
pDb->endTransaction();
// When: query Age, and Name, with SelectionArgs "Age = 10 OR Age = 38"
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
std::string selection = "Age = ? OR Age = ?";
std::vector<std::string> selectionArgs;
selectionArgs.push_back("10");
selectionArgs.push_back("38");
SqliteCursor::Ptr pCursor = pDb->query(DatabaseTableName, &columns, &selection, &selectionArgs, NULL, NULL, NULL,
NULL, false);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10},
{3, "Homer Simpson", "Springfield", 38}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, rawQuery_ReturnsQueryResult_WhenSelectionArgsExists)
{
// Given: create database
createDefaultDatabaseTable();
// When: buidQueryString and
// call rawQuery with selectionArgs "Age = 10"
std::string where = "Age = ?";
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
std::string queryString = SqliteQueryBuilder::buildQueryString(DatabaseTableName, &columns, &where, NULL, NULL,
NULL, NULL, false);
std::vector<std::string> selectionArgs;
selectionArgs.push_back("10");
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
SqliteCursor::Ptr pCursor = pDb->rawQuery(queryString, &selectionArgs);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, rawQuery_ReturnsQueryResult_WhenSelectionArgsExistsMulti)
{
// Given: create database and inset data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
// When: buidQueryString and
// call rawQuery with selectionArgs "Age = 10 OR Age = 38"
std::string where = "Age = ? OR Age = ?";
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
std::string queryString = SqliteQueryBuilder::buildQueryString(DatabaseTableName, &columns, &where, NULL, NULL,
NULL, NULL, false);
std::vector<std::string> selectionArgs;
selectionArgs.push_back("10");
selectionArgs.push_back("38");
SqliteCursor::Ptr pCursor = pDb->rawQuery(queryString, &selectionArgs);
// Then: verify query result
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10},
{3, "Homer Simpson", "Springfield", 38}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsOnlyDistinctValues_WhenDistinctIsTrue)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Nobi Nobita");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 10);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
pDb->endTransaction();
// call query with distinct false, and verify query result row count is 3
std::vector<std::string> columns;
columns.push_back("Age");
SqliteCursor::Ptr pCursor1 = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, false);
EXPECT_EQ(3, pCursor1->getCount());
RowElement expectedRows1[] = {
{1, "", "", 12},
{2, "", "", 10},
{3, "", "", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedRows1); i++) {
EXPECT_TRUE(databaseHasRow(pCursor1, expectedRows1[i]));
}
// When: call query with distinct true
SqliteCursor::Ptr pCursor2 = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, true);
// Then: verify query result, duplicate value should be removed
EXPECT_EQ(2, pCursor2->getCount());
RowElement expectedRows2[] = {
{1, "", "", 12},
{2, "", "", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedRows2); i++) {
EXPECT_TRUE(databaseHasRow(pCursor2, expectedRows2[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsAllMatchingValues_WhenDistinctIsTrue)
{
// Given: create database and insert data
createDefaultDatabaseTable();
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Nobi Nobita");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 10);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
pDb->insert(DatabaseTableName, *(pContentValues.get()));
pDb->setTransactionSuccessful();
pDb->endTransaction();
// call query with distinct false, and verify query result row count is 3
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
SqliteCursor::Ptr pCursor1 = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, false);
RowElement expectedRows1[] = {
{1, "Bart Simpson", "", 12},
{2, "Lisa Simpson", "", 10},
{3, "Nobi Nobita", "", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedRows1); i++) {
EXPECT_TRUE(databaseHasRow(pCursor1, expectedRows1[i]));
}
EXPECT_EQ(3, pCursor1->getCount());
// When: call query with distinct true
SqliteCursor::Ptr pCursor2 = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, true);
// Then: verify query result, duplicate value should be removed
RowElement expectedRows2[] = {
{1, "Bart Simpson", "", 12},
{2, "Lisa Simpson", "", 10},
{3, "Nobi Nobita", "", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedRows2); i++) {
EXPECT_TRUE(databaseHasRow(pCursor2, expectedRows2[i]));
}
EXPECT_EQ(3, pCursor2->getCount());
}
TEST_F(SqliteDatabaseIntegrationTest, query_Succeeds_ByAnotherInstance)
{
// Given: create database
createDefaultDatabaseTable();
// query and verify result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
// When: OpenDatabase by using another helper, and query database
Poco::Path databasePath(DatabaseDirString, DatabaseFileName);
PartialMockSqliteOpenHelper::Ptr pHelper = new PartialMockSqliteOpenHelper(databasePath, 1);
EXPECT_CALL(*pHelper, onCreate(testing::_)).Times(testing::AnyNumber());
EXPECT_CALL(*pHelper, onConfigure(testing::_)).Times(testing::AnyNumber());
EXPECT_CALL(*pHelper, onOpen(testing::_)).Times(testing::AnyNumber());
EXPECT_CALL(*pHelper, onUpgrade(testing::_, testing::_, testing::_)).Times(testing::AnyNumber());
EXPECT_CALL(*pHelper, onDowngrade(testing::_, testing::_, testing::_)).Times(testing::AnyNumber());
//
SqliteDatabase::Ptr pDb = pHelper->getWritableDatabase();
SqliteCursor::Ptr pCursor1 = pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, false);
// Then: verify query result
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor1, expectedExistRows[i]));
}
pHelper->close();
}
TEST_F(SqliteDatabaseIntegrationTest, query_ReturnsQueryResult_WhenDatabaseHasNoData)
{
// Given: create database
createDefaultDatabaseTableWithoutData();
// When: query database
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
// Then: the cursor does not have raw
EXPECT_EQ(0, pCursor->getCount());
}
TEST_F(SqliteDatabaseIntegrationTest, query_ThrowsSqlIllegalStateException_AfterClose)
{
// Given: create database
createDefaultDatabaseTable();
// When: close SqliteDatabase
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->close();
// Then: query throws exception
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
EASYHTTPCPP_ASSERT_THROW(pDb->query(DatabaseTableName, &columns, NULL, NULL, NULL, NULL, NULL, NULL, false),
SqlIllegalStateException, 100201);
}
TEST_F(SqliteDatabaseIntegrationTest, execSql_Succeeds_WhenExecuteInsert)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Homer Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmNone);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->execSql(insertString);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
{3, "Homer Simpson", "Springfield", 38}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, execSql_Succeeds_WhenExecuteUpdate)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Springfield");
pContentValues->put("Age", 38);
std::string whereClause = "Age = 10";
std::string updateString = SqliteQueryBuilder::buildUpdateString(DatabaseTableName, *pContentValues,
&whereClause, SqliteConflictAlgorithmNone);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->execSql(updateString);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 38},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, execSql_Succeeds_WhenExecuteDelete)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
std::string whereClause = "Age = 10";
std::string deleteString = SqliteQueryBuilder::buildDeleteString(DatabaseTableName, &whereClause);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->execSql(deleteString);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest,
insertWithConflictAlgorithmNone_ThrowsSqlExecutionException_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmNone);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
EASYHTTPCPP_ASSERT_THROW_WITH_CAUSE(pDb->execSql(insertString), SqlExecutionException, 100202);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest,
insertWithConflictAlgorithmRollback_ThrowsSqlExecutionException_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmRollback);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
pDb->beginTransaction();
EASYHTTPCPP_ASSERT_THROW_WITH_CAUSE(pDb->execSql(insertString), SqlExecutionException, 100202);
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest,
insertWithConflictAlgorithmAbort_ThrowsSqlExecutionException_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmAbort);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
EASYHTTPCPP_ASSERT_THROW_WITH_CAUSE(pDb->execSql(insertString), SqlExecutionException, 100202);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest,
insertWithConflictAlgorithmFail_ThrowsSqlExecutionException_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmFail);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
EASYHTTPCPP_ASSERT_THROW_WITH_CAUSE(pDb->execSql(insertString), SqlExecutionException, 100202);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest,
insertWithConflictAlgorithmIgnore_Succeeds_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmIgnore);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->execSql(insertString);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Tokyo", 15},
{3, "Lisa Simpson", "Tokyo", 15}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, insertWithConflictAlgorithmReplace_Succeeds_WhenTryToInsertDataTheNameIsRedundant)
{
// Given: create database
createDefaultDatabaseTable();
// When: insert data
Poco::AutoPtr<ContentValues> pContentValues = new ContentValues();
pContentValues->put("Name", "Lisa Simpson");
pContentValues->put("Address", "Tokyo");
pContentValues->put("Age", 15);
std::string insertString = SqliteQueryBuilder::buildInsertString(DatabaseTableName, *pContentValues,
SqliteConflictAlgorithmReplace);
SqliteDatabase::Ptr pDb = m_pTestUtil->getDatabase();
AutoSqliteTransaction autoTransaction(pDb);
pDb->execSql(insertString);
pDb->setTransactionSuccessful();
// Then: query Age, and Name, and verify query result
std::vector<std::string> columns;
columns.push_back("Age");
columns.push_back("Name");
columns.push_back("Address");
columns.push_back("Id");
SqliteCursor::Ptr pCursor = queryDatabase(DatabaseTableName, &columns);
EXPECT_EQ(2, pCursor->getCount());
EXPECT_TRUE(databaseHasColumns(pCursor, 4, columns));
RowElement expectedExistRows[] = {
{1, "Bart Simpson", "Springfield", 12},
{3, "Lisa Simpson", "Tokyo", 15},
};
for (size_t i = 0; i < ELEMENT_NUM(expectedExistRows); i++) {
EXPECT_TRUE(databaseHasRow(pCursor, expectedExistRows[i]));
}
RowElement expectedNonExistRows[] = {
{2, "Lisa Simpson", "Springfield", 10}
};
for (size_t i = 0; i < ELEMENT_NUM(expectedNonExistRows); i++) {
EXPECT_FALSE(databaseHasRow(pCursor, expectedNonExistRows[i]));
}
}
TEST_F(SqliteDatabaseIntegrationTest, setVersion_Succeeds)
{
// Given: create database
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
Poco::Data::SQLite::Connector::registerConnector();
SqliteDatabase::Ptr pDb = SqliteDatabase::openOrCreateDatabase(databaseFilePath.toString());
// When: set version
EXPECT_EQ(0, pDb->getVersion());
pDb->setVersion(1);
// Then: version has been updated
EXPECT_EQ(1, pDb->getVersion());
}
TEST_F(SqliteDatabaseIntegrationTest, setVersion_ThrowsSqlIllegalStateException_AfterClose)
{
// Given: create database
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
Poco::Data::SQLite::Connector::registerConnector();
SqliteDatabase::Ptr pDb = SqliteDatabase::openOrCreateDatabase(databaseFilePath.toString());
// When: Close the database
pDb->close();
// Then: throws SqlIllegalStateException
EASYHTTPCPP_ASSERT_THROW(pDb->setVersion(1), SqlIllegalStateException, 100201);
}
TEST_F(SqliteDatabaseIntegrationTest, setAutoVacuum_Succeeds)
{
// Given: create database
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
Poco::Data::SQLite::Connector::registerConnector();
SqliteDatabase::Ptr pDb = SqliteDatabase::openOrCreateDatabase(databaseFilePath.toString());
// When: set AutoVacuumIncremental
EXPECT_EQ(SqliteDatabase::AutoVacuumNone, pDb->getAutoVacuum());
pDb->setAutoVacuum(SqliteDatabase::AutoVacuumIncremental);
// Then: AutoVacuum has been updated
EXPECT_EQ(SqliteDatabase::AutoVacuumIncremental, pDb->getAutoVacuum());
}
TEST_F(SqliteDatabaseIntegrationTest, setAutoVacuum_ThrowsSqlIllegalStateException_AfterClose)
{
// Given: create database
Poco::Path databaseFilePath(DatabaseDirString, DatabaseFileName);
Poco::Data::SQLite::Connector::registerConnector();
SqliteDatabase::Ptr pDb = SqliteDatabase::openOrCreateDatabase(databaseFilePath.toString());
// When: Close the database
pDb->close();
// Then: throws SqlIllegalStateException
EASYHTTPCPP_ASSERT_THROW(pDb->setAutoVacuum(SqliteDatabase::AutoVacuumIncremental), SqlIllegalStateException, 100201);
}
} /* namespace test */
} /* namespace db */
} /* namespace easyhttpcpp */
| 34.556913 | 122 | 0.678279 | commshare |
b3392d29bb58dbf1bb0761a9f19bbdd1067bbd55 | 12,390 | cpp | C++ | src/main/cpp/Encoders.cpp | AlphaDragon601/SwerveDrive2_2022 | 7e575906ea71803ece25ee293cd74e0e9ea322b5 | [
"BSD-3-Clause"
] | null | null | null | src/main/cpp/Encoders.cpp | AlphaDragon601/SwerveDrive2_2022 | 7e575906ea71803ece25ee293cd74e0e9ea322b5 | [
"BSD-3-Clause"
] | null | null | null | src/main/cpp/Encoders.cpp | AlphaDragon601/SwerveDrive2_2022 | 7e575906ea71803ece25ee293cd74e0e9ea322b5 | [
"BSD-3-Clause"
] | null | null | null | /*
Encoders.cpp
Created on: Jan 3, 2020
Author: 5561
*/
#include "rev/CANSparkMax.h"
#include <frc/AnalogInput.h>
#include "Enums.hpp"
#include <frc/smartdashboard/SmartDashboard.h>
#include "Encoders.hpp"
#include "Const.hpp"
double V_WheelAngleRaw[E_RobotCornerSz];
double V_WheelAngle[E_RobotCornerSz];
double V_WheelAngleFwd[E_RobotCornerSz]; // This is the wheel angle as if the wheel were going to be driven in a forward direction, in degrees
double V_Rad_WheelAngleFwd[E_RobotCornerSz]; // This is the wheel angle as if the wheel were going to be driven in a forward direction, in radians
double V_WheelAngleRev[E_RobotCornerSz]; // This is the wheel angle as if the wheel were going to be driven in a reverse direction
double V_WheelAngleArb[E_RobotCornerSz]; // This is the arbitrated wheel angle that is used in the PID controller
double V_WheelAnglePrev[E_RobotCornerSz];
double V_WheelAngleLoop[E_RobotCornerSz];
double V_WheelRelativeAngleRawOffset[E_RobotCornerSz];
double V_WheelVelocity[E_RobotCornerSz]; // Velocity of drive wheels, in in/sec
double V_M_WheelDeltaDistance[E_RobotCornerSz]; // Distance wheel moved, loop to loop, in inches
double V_Cnt_WheelDeltaDistanceCurr[E_RobotCornerSz]; // Prev distance wheel moved, loop to loop, in Counts
double V_Cnt_WheelDeltaDistancePrev[E_RobotCornerSz]; // Prev distance wheel moved, loop to loop, in Counts
double V_ShooterSpeedCurr[E_RoboShooter];
double V_Cnt_WheelDeltaDistanceInit[E_RobotCornerSz];
double V_Delta_Angle[E_RobotCornerSz]; // The delta of the angle needed to align the wheels when the robot inits
/******************************************************************************
* Function: Init_Delta_Angle
*
* Description: Stores the delta value for wheel angles.
******************************************************************************/
void Init_Delta_Angle(double *L_Delta_Angle,
double a_encoderFrontLeftSteerVoltage,
double a_encoderFrontRightSteerVoltage,
double a_encoderRearLeftSteerVoltage,
double a_encoderRearRightSteerVoltage,
rev::SparkMaxRelativeEncoder m_encoderFrontLeftSteer,
rev::SparkMaxRelativeEncoder m_encoderFrontRightSteer,
rev::SparkMaxRelativeEncoder m_encoderRearLeftSteer,
rev::SparkMaxRelativeEncoder m_encoderRearRightSteer)
{
L_Delta_Angle[E_FrontLeft] = a_encoderFrontLeftSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_FrontLeft];
L_Delta_Angle[E_FrontRight] = a_encoderFrontRightSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_FrontRight];
L_Delta_Angle[E_RearLeft] = a_encoderRearLeftSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_RearLeft];
L_Delta_Angle[E_RearRight] = a_encoderRearRightSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_RearRight];
m_encoderFrontLeftSteer.SetPosition(0);
m_encoderFrontRightSteer.SetPosition(0);
m_encoderRearLeftSteer.SetPosition(0);
m_encoderRearRightSteer.SetPosition(0);
frc::SmartDashboard::PutNumber("Right rear aelta dngle", L_Delta_Angle[E_RearRight]);
frc::SmartDashboard::PutNumber("Left rear aelta dngle", L_Delta_Angle[E_RearLeft]);
}
/******************************************************************************
* Function: Read_Encoders
*
* Description: Run all of the encoder decoding logic.
******************************************************************************/
void Read_Encoders(bool L_RobotInit,
double a_encoderFrontLeftSteerVoltage,
double a_encoderFrontRightSteerVoltage,
double a_encoderRearLeftSteerVoltage,
double a_encoderRearRightSteerVoltage,
rev::SparkMaxRelativeEncoder m_encoderFrontLeftSteer,
rev::SparkMaxRelativeEncoder m_encoderFrontRightSteer,
rev::SparkMaxRelativeEncoder m_encoderRearLeftSteer,
rev::SparkMaxRelativeEncoder m_encoderRearRightSteer,
rev::SparkMaxRelativeEncoder m_encoderFrontLeftDrive,
rev::SparkMaxRelativeEncoder m_encoderFrontRightDrive,
rev::SparkMaxRelativeEncoder m_encoderRearLeftDrive,
rev::SparkMaxRelativeEncoder m_encoderRearRightDrive,
rev::SparkMaxRelativeEncoder m_encoderrightShooter,
rev::SparkMaxRelativeEncoder m_encoderleftShooter)
{
T_RobotCorner index;
//L_RobotInit = true; // For calibration only!
if (L_RobotInit == true)
{
V_WheelAngleRaw[E_FrontLeft] = a_encoderFrontLeftSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_FrontLeft];
V_WheelAngleRaw[E_FrontRight] = a_encoderFrontRightSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_FrontRight];
V_WheelAngleRaw[E_RearLeft] = a_encoderRearLeftSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_RearLeft];
V_WheelAngleRaw[E_RearRight] = a_encoderRearRightSteerVoltage * C_VoltageToAngle - K_WheelOffsetAngle[E_RearRight];
V_WheelRelativeAngleRawOffset[E_FrontLeft] = m_encoderFrontLeftSteer.GetPosition();
V_WheelRelativeAngleRawOffset[E_FrontRight] = m_encoderFrontRightSteer.GetPosition();
V_WheelRelativeAngleRawOffset[E_RearLeft] = m_encoderRearLeftSteer.GetPosition();
V_WheelRelativeAngleRawOffset[E_RearRight] = m_encoderRearRightSteer.GetPosition();
for (index = E_FrontLeft;
index < E_RobotCornerSz;
index = T_RobotCorner(int(index) + 1))
{
if(abs(V_WheelAnglePrev[index]) >= 330 || abs(V_WheelAnglePrev[index] <= 30 ))
{
if(V_WheelAnglePrev[index] >= 330 && V_WheelAngleRaw[index] <= 30)
{
V_WheelAngleLoop[index] += 1;
}
else if (V_WheelAnglePrev[index] <= 30 && V_WheelAngleRaw[index] >= 330)
{
V_WheelAngleLoop[index] -= 1;
}
}
V_WheelAngleFwd[index] = (V_WheelAngleLoop[index] * 360) + V_WheelAngleRaw[index];
V_WheelAnglePrev[index] = V_WheelAngleRaw[index];
}
V_Cnt_WheelDeltaDistanceInit[E_FrontLeft] = m_encoderFrontLeftDrive.GetPosition();
V_Cnt_WheelDeltaDistanceInit[E_FrontRight] = m_encoderFrontRightDrive.GetPosition();
V_Cnt_WheelDeltaDistanceInit[E_RearRight] = m_encoderRearRightDrive.GetPosition();
V_Cnt_WheelDeltaDistanceInit[E_RearLeft] = m_encoderRearLeftDrive.GetPosition();
}
else
{
V_WheelAngleFwd[E_FrontLeft] = fmod(((m_encoderFrontLeftSteer.GetPosition() - V_WheelRelativeAngleRawOffset[E_FrontLeft]) * -20), 360);
V_WheelAngleFwd[E_FrontRight] = fmod(((m_encoderFrontRightSteer.GetPosition() - V_WheelRelativeAngleRawOffset[E_FrontRight]) * -20), 360);
V_WheelAngleFwd[E_RearLeft] = fmod(((m_encoderRearLeftSteer.GetPosition() - V_WheelRelativeAngleRawOffset[E_RearLeft]) * -20), 360);
V_WheelAngleFwd[E_RearRight] = fmod(((m_encoderRearRightSteer.GetPosition() - V_WheelRelativeAngleRawOffset[E_RearRight]) * -20), 360);
for (index = E_FrontLeft;
index < E_RobotCornerSz;
index = T_RobotCorner(int(index) + 1))
{
if (V_WheelAngleFwd[index] > 180)
{
V_WheelAngleFwd[index] -= 360;
}
else if (V_WheelAngleFwd[index] < -180)
{
V_WheelAngleFwd[index] += 360;
}
/* Now we need to find the equivalent angle as if the wheel were going to be driven in the opposite direction, i.e. in reverse */
if (V_WheelAngleFwd[index] >= 0)
{
V_WheelAngleRev[index] = V_WheelAngleFwd[index] - 180;
}
else
{
V_WheelAngleRev[index] = V_WheelAngleFwd[index] + 180;
}
}
}
frc::SmartDashboard::PutNumber("V_WheelAngleRaw Front Left", V_WheelAngleRaw[E_FrontLeft]);
frc::SmartDashboard::PutNumber("V_WheelAngleRaw Front Right", V_WheelAngleRaw[E_FrontRight]);
frc::SmartDashboard::PutNumber("V_WheelAngleRaw Rear Left", V_WheelAngleRaw[E_RearLeft]);
frc::SmartDashboard::PutNumber("V_WheelAngleRaw Rear Right", V_WheelAngleRaw[E_RearRight]);
frc::SmartDashboard::PutNumber("encoder_rear_right_steer", m_encoderRearRightSteer.GetPosition());
if (L_RobotInit == false)
{
V_Cnt_WheelDeltaDistanceCurr[E_FrontLeft] = m_encoderFrontLeftDrive.GetPosition() - V_Cnt_WheelDeltaDistanceInit[E_FrontLeft];
V_Cnt_WheelDeltaDistanceCurr[E_FrontRight] = m_encoderFrontRightDrive.GetPosition() - V_Cnt_WheelDeltaDistanceInit[E_FrontRight];
V_Cnt_WheelDeltaDistanceCurr[E_RearRight] = m_encoderRearRightDrive.GetPosition() - V_Cnt_WheelDeltaDistanceInit[E_RearRight];
V_Cnt_WheelDeltaDistanceCurr[E_RearLeft] = m_encoderRearLeftDrive.GetPosition() - V_Cnt_WheelDeltaDistanceInit[E_RearLeft];
V_M_WheelDeltaDistance[E_FrontLeft] = ((((V_Cnt_WheelDeltaDistanceCurr[E_FrontLeft] - V_Cnt_WheelDeltaDistancePrev[E_FrontLeft])/ K_ReductionRatio)) * K_WheelCircufrence );
V_M_WheelDeltaDistance[E_FrontRight] = ((((V_Cnt_WheelDeltaDistanceCurr[E_FrontRight] - V_Cnt_WheelDeltaDistancePrev[E_FrontRight])/ K_ReductionRatio)) * K_WheelCircufrence );
V_M_WheelDeltaDistance[E_RearRight] = ((((V_Cnt_WheelDeltaDistanceCurr[E_RearRight] - V_Cnt_WheelDeltaDistancePrev[E_RearRight])/ K_ReductionRatio)) * K_WheelCircufrence );
V_M_WheelDeltaDistance[E_RearLeft] = ((((V_Cnt_WheelDeltaDistanceCurr[E_RearLeft] - V_Cnt_WheelDeltaDistancePrev[E_RearLeft])/ K_ReductionRatio)) * K_WheelCircufrence );
V_Cnt_WheelDeltaDistancePrev[E_FrontLeft] = V_Cnt_WheelDeltaDistanceCurr[E_FrontLeft];
V_Cnt_WheelDeltaDistancePrev[E_FrontRight] = V_Cnt_WheelDeltaDistanceCurr[E_FrontRight];
V_Cnt_WheelDeltaDistancePrev[E_RearRight] = V_Cnt_WheelDeltaDistanceCurr[E_RearRight];
V_Cnt_WheelDeltaDistancePrev[E_RearLeft] = V_Cnt_WheelDeltaDistanceCurr[E_RearLeft];
}
for (index = E_FrontLeft;
index < E_RobotCornerSz;
index = T_RobotCorner(int(index) + 1))
{
/* Create a copy of the Angle Fwd, but in radians */
V_Rad_WheelAngleFwd[index] = V_WheelAngleFwd[index] * (C_PI/180);
}
frc::SmartDashboard::PutNumber("Wheel Front Left", ((V_Cnt_WheelDeltaDistanceCurr[E_FrontLeft] / K_ReductionRatio) / 60) * K_WheelCircufrence);
V_WheelVelocity[E_FrontLeft] = ((m_encoderFrontLeftDrive.GetVelocity() / K_ReductionRatio) / 60) * K_WheelCircufrence;
V_WheelVelocity[E_FrontRight] = ((m_encoderFrontRightDrive.GetVelocity() / K_ReductionRatio) / 60) * K_WheelCircufrence;
V_WheelVelocity[E_RearRight] = ((m_encoderRearRightDrive.GetVelocity() / K_ReductionRatio) / 60) * K_WheelCircufrence;
V_WheelVelocity[E_RearLeft] = ((m_encoderRearLeftDrive.GetVelocity() / K_ReductionRatio) / 60) * K_WheelCircufrence;
V_ShooterSpeedCurr[E_rightShooter] = (m_encoderrightShooter.GetVelocity() * K_ShooterWheelRotation[E_rightShooter]);
V_ShooterSpeedCurr[E_leftShooter] = (m_encoderleftShooter.GetVelocity() * K_ShooterWheelRotation[E_leftShooter]);
frc::SmartDashboard::PutNumber("Top speed current", m_encoderrightShooter.GetVelocity());
frc::SmartDashboard::PutNumber("Bottom speed current", m_encoderleftShooter.GetVelocity());
frc::SmartDashboard::PutBoolean("init?", L_RobotInit);
}
/******************************************************************************
* Function: DtrmnEncoderRelativeToCmnd
*
* Description: tbd
******************************************************************************/
double DtrmnEncoderRelativeToCmnd(double L_JoystickCmnd,
double L_EncoderReading)
{
double L_Opt1;
double L_Opt2;
double L_Opt3;
double L_Output;
L_Opt1 = fabs(L_JoystickCmnd - L_EncoderReading);
L_Opt2 = fabs(L_JoystickCmnd - (L_EncoderReading + 360));
L_Opt3 = fabs(L_JoystickCmnd - (L_EncoderReading - 360));
if ((L_Opt1 < L_Opt2) && (L_Opt1 < L_Opt3))
{
L_Output = L_EncoderReading;
}
else if ((L_Opt2 < L_Opt1) && (L_Opt2 < L_Opt3))
{
L_Output = L_EncoderReading + 360;
}
else
{
L_Output = L_EncoderReading - 360;
}
return (L_Output);
}
| 52.723404 | 182 | 0.695238 | AlphaDragon601 |
b33cc8d3b447236f074bd9fd1d238079ae9b3eac | 4,431 | cpp | C++ | src/patternScan/TriangleScanner.cpp | sroehling/ChartPatternRecognitionLib | d9bd25c0fc5a8942bb98c74c42ab52db80f680c1 | [
"MIT"
] | 9 | 2019-07-15T19:10:07.000Z | 2021-12-14T12:16:18.000Z | src/patternScan/TriangleScanner.cpp | sroehling/ChartPatternRecognitionLib | d9bd25c0fc5a8942bb98c74c42ab52db80f680c1 | [
"MIT"
] | null | null | null | src/patternScan/TriangleScanner.cpp | sroehling/ChartPatternRecognitionLib | d9bd25c0fc5a8942bb98c74c42ab52db80f680c1 | [
"MIT"
] | 2 | 2020-05-23T03:25:25.000Z | 2021-11-19T16:41:44.000Z | /*
* WedgeScanner.cpp
*
* Created on: Aug 1, 2014
* Author: sroehling
*/
#include <TriangleScanner.h>
#include "ChartSegment.h"
#include "DebugLog.h"
TriangleScanner::TriangleScanner(const DoubleRange &upperTrendLineSlopeRange,
const DoubleRange &lowerTrendLineSlopeRange)
: upperTrendLineSlopeRange_(upperTrendLineSlopeRange),
lowerTrendLineSlopeRange_(lowerTrendLineSlopeRange)
{
minPercDistanceToUpperLowerTrendlineIntercept_ = 0.6;
minPercValsBetweenTrendlines_ = 0.85;
}
bool TriangleScanner::pivotsSpacedOut(const ChartSegmentPtr &upperTrendLine,
const ChartSegmentPtr &lowerTrendLine) const
{
double numPerToIntercept = numPeriodsToIntercept(upperTrendLine,lowerTrendLine);
assert(numPerToIntercept > 0.0);
// If the distance between the pivot points doesn't cover a reasonable amount
// of the pattern, the pattern will look "bunched up" in one area.
double MIN_SPACING_PERC = 0.30;
double pivotLowSpacing = lowerTrendLine->lastPeriodVal().pseudoXVal()-lowerTrendLine->firstPeriodVal().pseudoXVal();
assert(pivotLowSpacing <= numPerToIntercept);
if((pivotLowSpacing/numPerToIntercept) < MIN_SPACING_PERC)
{
return false;
}
double pivotHighSpacing = upperTrendLine->lastPeriodVal().pseudoXVal()-upperTrendLine->firstPeriodVal().pseudoXVal();
if(pivotHighSpacing >= numPerToIntercept)
{
DEBUG_MSG("ERROR: WedgeScanner: "
<< " pivot high space: " << pivotHighSpacing
<< " intercept periods: " << numPerToIntercept);
}
assert(pivotHighSpacing <= numPerToIntercept);
if(pivotHighSpacing > numPerToIntercept)
{
DEBUG_MSG("WedgeScanner: "
<< " pivot high space: " << pivotHighSpacing
<< " intercept periods: " << numPerToIntercept);
}
if((pivotHighSpacing/numPerToIntercept) < MIN_SPACING_PERC)
{
return false;
}
return true;
}
bool TriangleScanner::validTrendLines(const ChartSegmentPtr &upperTrendLine, const ChartSegmentPtr &lowerTrendLine) const
{
if(!WedgeScannerEngine::validTrendLines(upperTrendLine,lowerTrendLine))
{
return false;
}
// For starters, the trend-line slope for the upper and lower trendlines must be within
// the acceptable ranges.
if(!(WedgeScannerEngine::validTrendlinePercChangePerYear(upperTrendLineSlopeRange_,upperTrendLine) &&
WedgeScannerEngine::validTrendlinePercChangePerYear(lowerTrendLineSlopeRange_,lowerTrendLine)))
{
return false;
}
if(!(upperTrendLineSlopeRange_.valueWithinRange(upperTrendLine->slope()) &&
lowerTrendLineSlopeRange_.valueWithinRange(lowerTrendLine->slope())))
{
return false;
}
// The first and last value of the upper and lower trend lines are the pivot highs and lows used to
// define the trend lines. With this in mind, we don't want to consider a pattern valid if
// there is not a pivot low before the second pivot high; in other words, the pattern is not
// considered valid (i.e., well-balanced) if both the pivot lows occur after both the pivot highs.
if(interceptAfter2ndLowerAndUpperPivot(upperTrendLine,lowerTrendLine))
{
if(!pivotsInterleaved(upperTrendLine,lowerTrendLine))
{
return false;
}
if(!pivotsSpacedOut(upperTrendLine,lowerTrendLine))
{
return false;
}
return true;
}
else
{
return false;
}
}
unsigned int TriangleScanner::minPatternPeriods(const ChartSegmentPtr &upperTrendLine,
const ChartSegmentPtr &lowerTrendLine) const
{
assert(validTrendLines(upperTrendLine,lowerTrendLine));
double numPeriodsToIntercept = this->numPeriodsToIntercept(upperTrendLine,lowerTrendLine);
double minPeriods = floor(minPercDistanceToUpperLowerTrendlineIntercept_ * numPeriodsToIntercept);
return minPeriods;
}
unsigned int TriangleScanner::maxPatternPeriods(const ChartSegmentPtr &upperTrendLine, const ChartSegmentPtr &lowerTrendLine) const
{
assert(validTrendLines(upperTrendLine,lowerTrendLine));
unsigned int maxPeriods = floor(this->numPeriodsToIntercept(upperTrendLine,lowerTrendLine));
DEBUG_MSG("WedgeScannerEngine: num periods to intercept: "
<< maxPeriods);
return maxPeriods;
}
TriangleScanner::~TriangleScanner() {
}
| 30.986014 | 131 | 0.713157 | sroehling |
b33fa5944016c9cda050601679f276ca6cbd4fe8 | 820 | tpp | C++ | src/delaunay_static_cpu_interpolator.tpp | bszhu/interpolators | 3a3274e5ce89a6532168b3305c013e2ab590a02c | [
"MIT"
] | null | null | null | src/delaunay_static_cpu_interpolator.tpp | bszhu/interpolators | 3a3274e5ce89a6532168b3305c013e2ab590a02c | [
"MIT"
] | 3 | 2021-04-03T23:09:23.000Z | 2021-06-25T09:07:36.000Z | src/delaunay_static_cpu_interpolator.tpp | bszhu/interpolators | 3a3274e5ce89a6532168b3305c013e2ab590a02c | [
"MIT"
] | null | null | null | #include "delaunay_static_cpu_interpolator.h"
template<typename index_t, int N_DIMS, int N_OPS>
DelaunayStaticCPUInterpolator<index_t, N_DIMS, N_OPS>::DelaunayStaticCPUInterpolator(
operator_set_evaluator_iface *supporting_point_evaluator,
const std::array<int, N_DIMS> &axes_points,
const std::array<double, N_DIMS> &axes_min,
const std::array<double, N_DIMS> &axes_max)
: DelaunayCPUInterpolatorBase<index_t, N_DIMS, N_OPS>(
supporting_point_evaluator, axes_points, axes_min, axes_max),
StaticCPUInterpolatorBase<index_t, N_DIMS, N_OPS>(
supporting_point_evaluator, axes_points, axes_min, axes_max),
InterpolatorBase<index_t, N_DIMS, N_OPS>(supporting_point_evaluator,
axes_points, axes_min, axes_max) {} | 54.666667 | 85 | 0.719512 | bszhu |
b342f0fe086bfb4beacf8b35ebe6fa79cd9f07a3 | 1,241 | cc | C++ | src/image/utils_test.cc | kofuk/pixel-terrain | f39e2a0120aab5a11311f57cfd1ab46efa65fddd | [
"MIT"
] | 2 | 2020-10-16T08:46:45.000Z | 2020-11-04T02:19:19.000Z | src/image/utils_test.cc | kofuk/minecraft-image-generator | ef2f7deb2daac7f7c2cfb468ef39e0cdc8b33db7 | [
"MIT"
] | null | null | null | src/image/utils_test.cc | kofuk/minecraft-image-generator | ef2f7deb2daac7f7c2cfb468ef39e0cdc8b33db7 | [
"MIT"
] | null | null | null | // SPDX-License-Identifier: MIT
#include <filesystem>
#include <boost/test/tools/interface.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/test/unit_test_suite.hpp>
#include "image/utils.hh"
#include "utils/path_hack.hh"
using namespace pixel_terrain;
BOOST_AUTO_TEST_CASE(make_output_name_test) {
std::filesystem::path path(PATH_STR_LITERAL("/foo/bar/foo.mca"));
std::filesystem::path out_dir(PATH_STR_LITERAL("/foobar"));
{
auto [name, ok] = image::make_output_name_by_input(path, out_dir);
BOOST_TEST(ok);
BOOST_TEST(name == PATH_STR_LITERAL("/foobar/foo.png"));
}
{
path = PATH_STR_LITERAL("/foo/bar.baz");
auto [name, ok] = image::make_output_name_by_input(path, out_dir);
BOOST_TEST(not ok);
}
}
BOOST_AUTO_TEST_CASE(format_output_name_test) {
BOOST_TEST(image::format_output_name("%X %Z", 1, 2) == "1 2");
BOOST_TEST(image::format_output_name("%X %Z", 10, 200) == "10 200");
BOOST_TEST(image::format_output_name("%", 10, 200) == "%");
BOOST_TEST(image::format_output_name("%%%X", 10, 200) == "%10");
BOOST_TEST(image::format_output_name("", 10, 200) == "");
BOOST_TEST(image::format_output_name("%a", 10, 200) == "%a");
}
| 32.657895 | 74 | 0.664786 | kofuk |
b3456298caec8573eb7cdddb733a121e383eba23 | 14,197 | cpp | C++ | src/LuaInterpolate.cpp | perweij/tundra | 3384818fcf389a897de2463119a7e00de9da70e0 | [
"MIT"
] | 262 | 2015-01-15T09:52:46.000Z | 2022-03-26T19:10:54.000Z | src/LuaInterpolate.cpp | perweij/tundra | 3384818fcf389a897de2463119a7e00de9da70e0 | [
"MIT"
] | 78 | 2015-01-23T09:10:45.000Z | 2021-04-25T03:02:53.000Z | src/LuaInterpolate.cpp | perweij/tundra | 3384818fcf389a897de2463119a7e00de9da70e0 | [
"MIT"
] | 44 | 2015-03-13T22:15:24.000Z | 2022-03-27T15:06:27.000Z |
#include "MemAllocHeap.hpp"
#include "Buffer.hpp"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
extern "C" {
#include "lua.h"
#include "lauxlib.h"
}
namespace t2
{
struct LuaEnvLookup
{
lua_State *m_LuaState;
int m_EnvIndex;
int m_VarIndex;
};
class LuaEnvLookupScope
{
private:
lua_State* m_LuaState;
bool m_Valid;
size_t m_Count;
public:
explicit LuaEnvLookupScope(LuaEnvLookup& lookup, const char* key, size_t len)
{
m_LuaState = lookup.m_LuaState;
m_Valid = false;
lua_State* L = lookup.m_LuaState;
// If we have a table of per-call variables, look there first.
if (int var_table_idx = lookup.m_VarIndex)
{
lua_getfield(L, var_table_idx, key);
if (!lua_isnil(L, -1))
{
if (LUA_TTABLE != lua_type(L, -1))
{
lua_newtable(L);
lua_pushvalue(L, -2);
lua_rawseti(L, -2, 1);
lua_replace(L, -2);
}
m_Count = lua_objlen(L, -1);
m_Valid = true;
return;
}
else
{
lua_pop(L, 1);
}
}
// Next, walk through the environment tables.
lua_pushvalue(L, lookup.m_EnvIndex);
while (!lua_isnil(L, -1))
{
lua_getfield(L, -1, "parent");
lua_getfield(L, -2, "vars");
// remove env table index from stack, replace it with its parent table
lua_remove(L, -3);
lua_getfield(L, -1, key);
if (!lua_isnil(L, -1))
{
luaL_checktype(L, -1, LUA_TTABLE);
lua_remove(L, -3);
lua_remove(L, -2);
m_Count = lua_objlen(L, -1);
m_Valid = true;
return;
}
// Pop nil value, and vars table. Leaving us with next table to try.
lua_pop(L, 2);
}
// Pop nil table.
lua_pop(L, 1);
luaL_error(L, "No key '%s' present in environment", key);
}
size_t GetCount()
{
return m_Count;
}
const char* GetValue(size_t index, size_t* len_out)
{
lua_State* L = m_LuaState;
CHECK(lua_type(L, -1) == LUA_TTABLE);
lua_rawgeti(L, -1, int(index + 1));
if (lua_type(L, -1) != LUA_TSTRING)
{
fprintf(stderr, "env lookup failed: elem %d is not a string: %s\n", (int) index + 1, lua_typename(L, lua_type(L, -1)));
return nullptr;
}
// This is technically not allowed but we do it anyway for performance.
// We check that the value is already a string, and we know it's being
// kept alive by the table which is on our stack.
const char* str = lua_tolstring(L, -1, len_out);
lua_pop(L, 1);
return str;
}
~LuaEnvLookupScope()
{
if (m_Valid)
{
lua_pop(m_LuaState, 1);
}
}
bool Valid()
{
return m_Valid;
}
private:
LuaEnvLookupScope(const LuaEnvLookupScope&);
LuaEnvLookupScope& operator=(const LuaEnvLookupScope&);
};
class StringBuffer
{
private:
enum
{
kInternalBufferSize = 64
};
MemAllocHeap *m_Heap;
size_t m_InternalBufferUsed;
char m_InternalBuffer[kInternalBufferSize];
Buffer<char> m_Buffer;
public:
explicit StringBuffer(MemAllocHeap* heap)
{
m_Heap = heap;
m_InternalBufferUsed = 0;
BufferInit(&m_Buffer);
}
~StringBuffer()
{
BufferDestroy(&m_Buffer, m_Heap);
}
void Add(const char* data, size_t len)
{
char* dest = Grow(len);
memcpy(dest, data, len);
}
char* Grow(size_t len)
{
if (m_Buffer.m_Size)
{
return BufferAlloc(&m_Buffer, m_Heap, len);
}
else if (len + m_InternalBufferUsed <= kInternalBufferSize)
{
size_t offset = m_InternalBufferUsed;
m_InternalBufferUsed += len;
return m_InternalBuffer + offset;
}
else
{
BufferAppend(&m_Buffer, m_Heap, m_InternalBuffer, m_InternalBufferUsed);
return BufferAlloc(&m_Buffer, m_Heap, len);
}
}
void Shrink(size_t size)
{
CHECK(size <= GetSize());
if (m_Buffer.m_Size)
{
m_Buffer.m_Size = size;
}
else
{
CHECK(size <= kInternalBufferSize);
m_InternalBufferUsed = size;
}
}
void NullTerminate()
{
Add("", 1);
}
MemAllocHeap* GetHeap()
{
return m_Heap;
}
size_t GetSize()
{
if (size_t sz = m_Buffer.m_Size)
return sz;
else
return m_InternalBufferUsed;
}
char* GetBuffer()
{
if (m_Buffer.m_Size)
return m_Buffer.m_Storage;
else
return m_InternalBuffer;
}
// Transformation functions invoked by interpolation options
void Prepend(const char* data, size_t len)
{
Grow(len);
char *buffer = GetBuffer();
size_t buflen = GetSize();
memmove(buffer + len, buffer, buflen - len);
memcpy(buffer, data, len);
}
void Append(const char* data, size_t len)
{
Add(data, len);
}
void PrependUnless(const char* data, size_t len)
{
if (len > GetSize() || 0 != memcmp(GetBuffer(), data, len))
{
Prepend(data, len);
}
}
void AppendUnless(const char* data, size_t data_len)
{
size_t len = GetSize();
char* buf = GetBuffer();
if (len < data_len || 0 != memcmp(buf + len - data_len, data, data_len))
{
Append(data, data_len);
}
}
void ToForwardSlashes()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (size_t i = 0; i < len; ++i)
{
if (buf[i] == '\\')
buf[i] = '/';
}
}
void ToBackSlashes()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (size_t i = 0; i < len; ++i)
{
if (buf[i] == '/')
buf[i] = '\\';
}
}
void ToUppercase()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (size_t i = 0; i < len; ++i)
{
buf[i] = (char) toupper(buf[i]);
}
}
void ToLowercase()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (size_t i = 0; i < len; ++i)
{
buf[i] = (char) tolower(buf[i]);
}
}
void DropSuffix()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (int i = (int) len - 1; i >= 0; --i)
{
if ('.' == buf[i])
{
Shrink(i);
break;
}
}
}
void GetFilename()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (int i = (int) len - 1; i >= 0; --i)
{
if ('/' == buf[i] || '\\' == buf[i])
{
int target_len = int(len - i - 1);
memmove(buf, buf + i + 1, target_len);
Shrink(target_len);
break;
}
}
}
void GetFilenameDir()
{
size_t len = GetSize();
char* buf = GetBuffer();
for (int i = (int) len - 1; i >= 0; --i)
{
if ('/' == buf[i] || '\\' == buf[i])
{
Shrink(i);
break;
}
}
}
void PrepQuoteCommon()
{
// Drop trailing backslash - can't be escaped on windows
{
size_t len = GetSize();
char* buf = GetBuffer();
if (len > 0 && buf[len - 1] == '\\')
Shrink(len - 1);
}
size_t bs_count = 0;
{
size_t len = GetSize();
char* buf = GetBuffer();
for (size_t i = 0; i < len; ++i)
{
if (buf[i] == '\\')
++bs_count;
}
}
if (bs_count > 0)
{
size_t orig_len = GetSize();
Grow(bs_count);
char* data = GetBuffer();
memmove(data + bs_count, data, orig_len);
size_t r = bs_count;
size_t w = 0;
while (r < orig_len + bs_count)
{
char ch = data[r++];
data[w++] = ch;
if (ch == '\\')
{
data[w++] = '\\';
}
}
}
}
void Quote()
{
// Avoid double quoting.
{
char* data = GetBuffer();
const size_t orig_len = GetSize();
if (orig_len > 0 && data[0] == '"' && data[orig_len-1] == '"')
{
// Already quoted. Make sure it doesn't end in a backslash.
if (orig_len > 1 && data[orig_len-2] == '\\')
{
Shrink(orig_len - 1);
size_t len = orig_len - 1;
data = GetBuffer();
data[len-1] = '"';
}
return;
}
}
PrepQuoteCommon();
Prepend("\"", 1);
Append("\"", 1);
}
void EscapeForCmdlineDefine()
{
PrepQuoteCommon();
Prepend("\\\"", 2);
Append("\\\"", 2);
}
private:
StringBuffer(const StringBuffer&);
StringBuffer& operator=(const StringBuffer&);
};
static bool DoInterpolate(StringBuffer& output, const char* str, size_t len, LuaEnvLookup& lookup);
static void UnescapeOption(char* p)
{
int r = 0;
int w = 0;
while (char ch = p[r++])
{
if ('\\' == ch)
{
if (p[r] == ':')
{
++r;
p[w++] = ':';
continue;
}
}
p[w++] = ch;
}
p[w++] = '\0';
}
static bool InterpolateVar(StringBuffer& output, const char* str, size_t len, LuaEnvLookup& lookup)
{
StringBuffer var_name(output.GetHeap());
if (!DoInterpolate(var_name, str, len, lookup))
return false;
var_name.NullTerminate();
enum
{
kMaxOptions = 10
};
size_t data_size = var_name.GetSize() - 1;
char *data = var_name.GetBuffer();
size_t option_count = 0;
char *option_ptrs[kMaxOptions];
if (char *options = strchr(data, ':'))
{
data_size = options - data;
while (nullptr != (options = strchr(options, ':')))
{
if (options[-1] == '\\')
{
++options;
continue;
}
if (option_count == kMaxOptions)
return false;
*options = '\0';
option_ptrs[option_count++] = options + 1;
++options;
}
for (size_t i = 0; i < option_count; ++i)
{
UnescapeOption(option_ptrs[i]);
}
}
LuaEnvLookupScope scope(lookup, data, data_size);
if (!scope.Valid())
return false;
const char *join_string = " ";
size_t first_index = 0;
size_t max_index = scope.GetCount();
for (size_t oi = 0; oi < option_count; ++oi)
{
const char* option = option_ptrs[oi];
switch (option[0])
{
case 'j':
join_string = &option[1];
break;
case '[':
first_index = atoi(&option[1]) - 1;
max_index = first_index + 1;
if (first_index >= scope.GetCount())
return false;
break;
}
}
const size_t join_len = strlen(join_string);
for (size_t i = first_index; i < max_index; ++i)
{
size_t item_len;
const char* item_text = scope.GetValue(i, &item_len);
if (!item_text)
return false;
StringBuffer item(output.GetHeap());
if (!DoInterpolate(item, item_text, item_len, lookup))
return false;
for (size_t oi = 0; oi < option_count; ++oi)
{
const char* option = option_ptrs[oi];
switch (option[0])
{
case 'p': item.Prepend(&option[1], strlen(&option[1])); break;
case 'a': item.Append(&option[1], strlen(&option[1])); break;
case 'P': item.PrependUnless(&option[1], strlen(&option[1])); break;
case 'A': item.AppendUnless(&option[1], strlen(&option[1])); break;
case 'f': item.ToForwardSlashes(); break;
case 'b': item.ToBackSlashes(); break;
case 'n':
#if defined(TUNDRA_WIN32)
item.ToBackSlashes();
#else
item.ToForwardSlashes();
#endif
break;
case 'u': item.ToUppercase(); break;
case 'l': item.ToLowercase(); break;
case 'B': item.DropSuffix(); break;
case 'F': item.GetFilename(); break;
case 'D': item.GetFilenameDir(); break;
case 'q': item.Quote(); break;
case '#': item.EscapeForCmdlineDefine(); break;
// Ignore these here
case '[': case 'j':
break;
default:
fprintf(stderr, "bad interpolation option: \"%s\"\n", option);
return false;
}
}
if (i > first_index)
output.Add(join_string, join_len);
output.Add(item.GetBuffer(), item.GetSize());
}
return true;
}
static const char* FindEndParen(const char* str, size_t len)
{
int nesting = 1;
for (size_t i = 0; i < len; ++i)
{
switch (str[i])
{
case '(':
++nesting;
break;
case ')':
if (--nesting == 0)
return str + i;
break;
}
}
return 0;
}
static bool DoInterpolate(StringBuffer& output, const char* str, size_t len, LuaEnvLookup& lookup)
{
const char* end = str + len;
while (str < end)
{
char ch = *str++;
if ('$' == ch)
{
if (end != str && '(' == str[0])
{
// Don't interpolate $(<) or $(@) without a lookaside table.
// We leave them in the string.
if (lookup.m_VarIndex || (str[1] != '<' && str[1] != '@'))
{
++str;
const char* end_paren = FindEndParen(str, end - str);
if (!end_paren)
{
fprintf(stderr, "unbalanced parens\n");
return false;
}
if (!InterpolateVar(output, str, end_paren - str, lookup))
return false;
str = end_paren + 1;
continue;
}
}
}
output.Add(&ch, 1);
}
return true;
}
// Interpolate a string with respect to a set of lookup tables.
//
// Calling interface:
// Arg 1 - String to interpolate
// Arg 2 - Top environment (we will follow "parent" links if needed)
// Arg 3 - Optional table of variables for this interpolation only
static int LuaInterpolate(lua_State* L)
{
size_t input_len;
const char* input = luaL_checklstring(L, 1, &input_len);
luaL_checktype(L, 2, LUA_TTABLE);
const bool has_vars = lua_type(L, 3) == LUA_TTABLE;
MemAllocHeap* heap;
lua_getallocf(L, (void**) &heap);
LuaEnvLookup lookup = { L, 2, has_vars ? 3 : 0 };
StringBuffer output(heap);
if (DoInterpolate(output, input, input_len, lookup))
{
lua_pushlstring(L, output.GetBuffer(), output.GetSize());
return 1;
}
return luaL_error(L, "interpolation failed: %s", input);
}
void LuaEnvNativeOpen(lua_State* L)
{
static luaL_Reg functions[] =
{
{ "interpolate", LuaInterpolate },
{ nullptr, nullptr },
};
luaL_register(L, "tundra.environment.native", functions);
lua_pop(L, 1);
}
}
| 21.032593 | 125 | 0.541241 | perweij |
b3458a8bc057840100266afbe0e26931be313b45 | 1,893 | cpp | C++ | POSN Camp1/toi_worldcup.cpp | ParamaaS/ParamaaS-Cpp-code- | a6c78151defe38d1460cde2b005a67be5a1d092d | [
"MIT"
] | null | null | null | POSN Camp1/toi_worldcup.cpp | ParamaaS/ParamaaS-Cpp-code- | a6c78151defe38d1460cde2b005a67be5a1d092d | [
"MIT"
] | null | null | null | POSN Camp1/toi_worldcup.cpp | ParamaaS/ParamaaS-Cpp-code- | a6c78151defe38d1460cde2b005a67be5a1d092d | [
"MIT"
] | null | null | null | #include<stdio.h>
char name[10][25];
int s[10][10],p[10],so[10],rem[10];
int c,c2,g[10],d[10],idx[10],dif[10];
main()
{
for(c=1;c<=4;c++)
{
scanf("%s",name[c]);
}
for(c=1;c<=4;c++)
{
for(c2=1;c2<=4;c2++)
{
scanf("%d",&s[c][c2]);
if(c==1) g[1]+=s[1][c2];
else if(c==2) g[2]+=s[2][c2];
else if(c==3) g[3]+=s[3][c2];
else if(c==4) g[4]+=s[4][c2];
if(c2==1) d[1]+=s[c][1];
else if(c2==2) d[2]+=s[c][2];
else if(c2==3) d[3]+=s[c][3];
else if(c2==4) d[4]+=s[c][4];
}
}
for(c=1;c<=4;c++)
{
dif[c]=g[c]-d[c];
}
for(c=1;c<=4;c++)
{
for(c2=1;c2<=4;c2++)
{
if(c==c2)
{
continue;
}
if(s[c][c2]>s[c2][c])
{
idx[c]+=3;
}
if(s[c][c2]==s[c2][c])
{
idx[c]++;
}
}
}
/*/
for(c=1;c<=4;c++)
{
printf("%s %d\n",name[c],idx[c]);
}
/*/
for(c=1;c<=4;c++)
{
so[c]=0;
for(c2=1;c2<=4;c2++)
{
if(so[c]<=idx[c2])
{
if(so[c]==idx[c2])
{
if(idx[rem[c]]==idx[c2]&&idx[c2]!=0)
{
if(dif[rem[c]]>dif[c2])
{
//rem[c]=rem[c];
so[c]=idx[rem[c]];
continue;
}
else if(dif[c2]>dif[rem[c]])
{
rem[c]=c2;
so[c]=idx[c2];
continue;
}
else if(dif[c2]==dif[rem[c]])
{
if(g[c2]>g[rem[c]])
{
rem[c]=c2;
so[c]=idx[c2];
continue;
}
else
{
rem[c]=rem[c];
so[c]=idx[rem[c]];
continue;
}
}
}
else if(idx[c2]==0&&idx[c2]==idx[rem[c]])
{
rem[c]=c2;
so[c]=idx[c2];
}
}
else
{
rem[c]=c2;
so[c]=idx[c2];
}
}
}
idx[rem[c]]=-1;
}
/*/
for(c=1;c<=4;c++)
{
printf("%d ",rem[c]);
}/*/
for(c=1;c<=4;c++)
{
printf("%s %d\n",name[rem[c]],so[c]);
}
}
| 15.907563 | 47 | 0.348653 | ParamaaS |
b3465a1ea06f2959df68fc58697a3aa36c2d89aa | 1,001 | cpp | C++ | src/UserData.cpp | maxmcguire/rocket | d7df8a698da25ed0aae125579fd2a58e3f07c48b | [
"MIT"
] | 6 | 2015-10-07T22:43:18.000Z | 2021-12-20T05:48:54.000Z | src/UserData.cpp | maxmcguire/rocket | d7df8a698da25ed0aae125579fd2a58e3f07c48b | [
"MIT"
] | null | null | null | src/UserData.cpp | maxmcguire/rocket | d7df8a698da25ed0aae125579fd2a58e3f07c48b | [
"MIT"
] | 3 | 2015-06-19T04:58:50.000Z | 2020-01-19T16:19:22.000Z | /*
* RocketVM
* Copyright (c) 2011 Max McGuire
*
* See copyright notice in COPYRIGHT
*/
extern "C"
{
#include "lua.h"
}
#include "Global.h"
#include "UserData.h"
#include "State.h"
#include "Table.h"
#include <stdlib.h>
UserData* UserData_Create(lua_State* L, size_t size, Table* env)
{
ASSERT(env != NULL);
UserData* userData = static_cast<UserData*>(Gc_AllocateObject(L, LUA_TUSERDATA, sizeof(UserData) + size));
userData->size = size;
userData->metatable = NULL;
userData->env = env;
Gc* gc = &L->gc;
Gc_IncrementReference(gc, userData, userData->env);
return userData;
}
void UserData_Destroy(lua_State* L, UserData* userData, bool releaseRefs)
{
if (releaseRefs)
{
Gc* gc = &L->gc;
if (userData->metatable != NULL)
{
Gc_DecrementReference(L, gc, userData->metatable);
}
Gc_DecrementReference(L, gc, userData->env);
}
Free(L, userData, sizeof(UserData) + userData->size);
} | 21.297872 | 110 | 0.629371 | maxmcguire |
b348374945b91d5b2125b34ffb65e00c20f0a5ab | 1,754 | cpp | C++ | KROSS/src/Kross/Util/Util.cpp | WillianKoessler/KROSS-ENGINE | 0e680b455ffd071565fe8b99343805ad16ca1e91 | [
"Apache-2.0"
] | null | null | null | KROSS/src/Kross/Util/Util.cpp | WillianKoessler/KROSS-ENGINE | 0e680b455ffd071565fe8b99343805ad16ca1e91 | [
"Apache-2.0"
] | null | null | null | KROSS/src/Kross/Util/Util.cpp | WillianKoessler/KROSS-ENGINE | 0e680b455ffd071565fe8b99343805ad16ca1e91 | [
"Apache-2.0"
] | null | null | null | #include "Kross_pch.h"
#include "Util.h"
namespace Kross {
void append(char *dest, size_t size, const char *str)
{
if (!dest || !str) return;
strcat_s(dest, size, str);
//std::string buffer(dest);
//std::string copy = buffer;
//buffer += str;
//size_t size = buffer.size();
//char *result = new char[size];
//memcpy(result, buffer.c_str(), size);
//size_t d = dest!=nullptr ? strlen(dest) : 0;
//size_t s = str!=nullptr ? strlen(str) : 0;
//char *cbuffer = new char[d+s+1];
//memset(cbuffer, 0, d + s + 1);
//memcpy(cbuffer, dest, d);
//memcpy(cbuffer + d, str, s);
//cbuffer[d+s] = '\0';
//char *temp = dest;
//dest = cbuffer;
//delete temp;
}
const char *ReadFile(const char *filepath)
{
std::ifstream inFile(filepath);
if (!inFile.is_open()) KROSS_ERROR("Unable to Open file: {0}", filepath);
std::stringstream stream;
stream << inFile.rdbuf();
inFile.close();
std::string str = stream.str();
size_t size = str.size();
char *ptr = new char[size+1];
memcpy(ptr, str.c_str(), size);
ptr[size] = '\0';
return ptr;
}
const char *FileName(const char *cpath)
{
if (cpath == nullptr) return nullptr;
std::string path(cpath);
size_t slash = path.find_last_of("/\\");
slash = (slash != std::string::npos) ? slash + 1 : 0;
size_t dot = path.find_last_of(".");
std::string name = path.substr(slash, dot);
size_t count = name.size();
char *ptr = new char[count + 1];
memcpy(ptr, name.c_str(), count);
ptr[count] = '\0';
return ptr;
}
int FlipBits(int &flags, int mask)
{
flags ^= mask;
return flags;
}
int ClearBits(int &flags, int mask)
{
flags &= ~mask;
return flags;
}
int SetBits(int &flags, int mask)
{
flags |= mask;
return flags;
}
}
| 21.654321 | 75 | 0.607754 | WillianKoessler |
b34a8d8475ac0a55251e620005705e06b8f649db | 316 | hpp | C++ | src/Qt5Gui/QTextDocumentFragment.hpp | dafrito/luacxx | 278bf8a7c6664536ea7f1dd1f59d35b6fb8d2dad | [
"MIT"
] | 128 | 2015-01-07T19:47:09.000Z | 2022-01-22T19:42:14.000Z | src/Qt5Gui/QTextDocumentFragment.hpp | dafrito/luacxx | 278bf8a7c6664536ea7f1dd1f59d35b6fb8d2dad | [
"MIT"
] | null | null | null | src/Qt5Gui/QTextDocumentFragment.hpp | dafrito/luacxx | 278bf8a7c6664536ea7f1dd1f59d35b6fb8d2dad | [
"MIT"
] | 24 | 2015-01-07T19:47:10.000Z | 2022-01-25T17:42:37.000Z | #ifndef luacxx_QTextDocumentFragment_INCLUDED
#define luacxx_QTextDocumentFragment_INCLUDED
#include "../stack.hpp"
#include <QTextDocumentFragment>
LUA_METATABLE_BUILT(QTextDocumentFragment)
extern "C" int luaopen_Qt5Gui_QTextDocumentFragment(lua_State* const);
#endif // luacxx_QTextDocumentFragment_INCLUDED
| 24.307692 | 70 | 0.857595 | dafrito |
b34f448a8229b80e4cdef61928bf2e012013e64b | 5,974 | cpp | C++ | lib/src/hamiltonian/kp/TI3DKpParams.cpp | mirzaelahi/quest | c433175802014386c2b1bf3c8932cd66b0d37c8e | [
"Apache-2.0"
] | null | null | null | lib/src/hamiltonian/kp/TI3DKpParams.cpp | mirzaelahi/quest | c433175802014386c2b1bf3c8932cd66b0d37c8e | [
"Apache-2.0"
] | null | null | null | lib/src/hamiltonian/kp/TI3DKpParams.cpp | mirzaelahi/quest | c433175802014386c2b1bf3c8932cd66b0d37c8e | [
"Apache-2.0"
] | null | null | null | /*
* File: TI3DKpParams.cpp
* Author: K M Masum Habib <masum.habib@gmail.com>
*
* Created on September 12, 2014, 9:49 AM
*/
#include "hamiltonian/kp/TI3DKpParams.h"
namespace qmicad{namespace hamiltonian{
TI3DKpParams::TI3DKpParams(const string material,
const string &prefix):cxhamparams(prefix)
{
mTitle = "Topological Insulator four band k.p parameters";
mI = eye<cxmat>(4,4);
mU = zeros<cxmat>(4,4);
mU(0, 0) = 1;
mU(1, 2) = 1;
mU(2, 1) = 1;
mU(3, 3) = 1;
setDefaultParams();
if (material == "Bi2Se3"){
setBi2Se3Params();
}else{
throw runtime_error(string("In TI3DKpParams(): ") + material + " is not implemented yet." );
}
update();
}
string TI3DKpParams::toString() const {
stringstream ss;
ss << cxhamparams::toString() << ":" << endl;
ss << mPrefix << " a = " << ma << endl;
ss << mPrefix << " dtol = " << mdtol << endl;
ss << mPrefix << " A1 = " << mA1 << endl;
ss << mPrefix << " A2 = " << mA2 << endl;
ss << mPrefix << " B1 = " << mB1 << endl;
ss << mPrefix << " B2 = " << mB2 << endl;
ss << mPrefix << " C = " << mC << endl;
ss << mPrefix << " D1 = " << mD1 << endl;
ss << mPrefix << " D2 = " << mD2 << endl;
ss << mPrefix << " M = " << mM << endl;
ss << mPrefix << " eps: " << endl << meps;
ss << mPrefix << " t01x: " << endl << mt01x;
ss << mPrefix << " t01y: " << endl << mt01y;
ss << mPrefix << " t01z: " << endl << mt01z;
return ss.str();
}
void TI3DKpParams::update(){
if(!(is_finite(mdtol) && is_finite(ma)
&& is_finite(mA1) && is_finite(mA2)
&& is_finite(mB1) && is_finite(mB2)
&& is_finite(mC)
&& is_finite(mD1) && is_finite(mD2)
&& is_finite(mM)
)){
throw runtime_error("In TI3DKpParams::update(): invalid TI parameters.");
}
double ax = ma, ay = ma, az = ma;
cxmat Go(4,4,fill::zeros);
cxmat Gx(4,4,fill::zeros), Gx2(4,4,fill::zeros);
cxmat Gy(4,4,fill::zeros), Gy2(4,4,fill::zeros);
cxmat Gz(4,4,fill::zeros), Gz2(4,4,fill::zeros);
// see TI notes, page 11.
Gx(0,3) = mA2;
Gx(1,2) = mA2;
Gx(2,1) = mA2;
Gx(3,0) = mA2;
Gx2(0,0) = mD2 - mB2;
Gx2(1,1) = mD2 + mB2;
Gx2(2,2) = mD2 - mB2;
Gx2(3,3) = mD2 + mB2;
Gy(0,3) = -i*mA2;
Gy(1,2) = -i*mA2;
Gy(2,1) = i*mA2;
Gy(3,0) = i*mA2;
Gy2(0,0) = mD2 - mB2;
Gy2(1,1) = mD2 + mB2;
Gy2(2,2) = mD2 - mB2;
Gy2(3,3) = mD2 + mB2;
Gz(0,1) = mA1;
Gz(1,0) = mA1;
Gz(2,3) = -mA1;
Gz(3,2) = -mA1;
Gz2(0,0) = mD1 - mB1;
Gz2(1,1) = mD1 + mB1;
Gz2(2,2) = mD1 - mB1;
Gz2(3,3) = mD1 + mB1;
Go(0,0) = mC + mM;
Go(1,1) = mC - mM;
Go(2,2) = mC + mM;
Go(3,3) = mC - mM;
meps = Go + (2/(ax*ax))*Gx2 + (2/(ay*ay))*Gy2 + (2/(az*az))*Gz2;
mt01x = (-i/(2*ax))*Gx - (1/(ax*ax))*Gx2;
mt01y = (-i/(2*ay))*Gy - (1/(ay*ay))*Gy2;
mt01z = (-i/(2*az))*Gz - (1/(az*az))*Gz2;
// change basis to |1, up> |1, dn> |2, up> |2, dn>
meps = trans(mU)*meps*mU;
mt01x = trans(mU)*mt01x*mU;
mt01y = trans(mU)*mt01y*mU;
mt01z = trans(mU)*mt01z*mU;
mt10x = trans(mt01x);
mt10y = trans(mt01y);
mt10z = trans(mt01z);
}
cxmat TI3DKpParams::twoAtomHam(const AtomicStruct& atomi,
const AtomicStruct& atomj) const
{
if (atomi.NumOfAtoms() > 1 || atomj.NumOfAtoms() > 1){
throw invalid_argument("TISurfHamGen(): atomi and atomj must should contain one atom each.");
}
int noi = atomi.NumOfOrbitals();
int noj = atomj.NumOfOrbitals();
cxmat hmat = zeros<cxmat>(noi, noj);
// calculate distance between atom i and atom j
double xi = atomi.X(0), yi = atomi.Y(0), zi = atomi.Z(0);
double xj = atomj.X(0), yj = atomj.Y(0), zj = atomj.Z(0);
double dx = abs(xi - xj), dy = abs(yi - yj), dz = abs(zi - zj);
double d = sqrt(dx*dx + dy*dy + dz*dz);
// Assign the the matrix elements based on the distance between
// the lattice points.
if (atomi.Symbol(0) == "D" && atomj.Symbol(0) == "D"){
// site energy
if (d <= mdtol){
hmat = meps;
// nearest neighbor in x
}else if(abs(d - ma) <= mdtol && abs(dx - ma) <= mdtol){
if (xi > xj){
hmat = mt10x;
}else{
hmat = mt01x;
}
//nearest neighbor y
}else if (abs(d - ma) <= mdtol && abs(dy - ma) <= mdtol){
if(yi > yj){
hmat = mt10y;
}else{
hmat = mt01y;
}
//nearest neighbor z
}else if (abs(d - ma) <= mdtol && abs(dz - ma) <= mdtol){
if(zi > zj){
hmat = mt10z;
}else{
hmat = mt01z;
}
}
}
return hmat;
}
cxmat TI3DKpParams::twoAtomOvl(const AtomicStruct& atomi,
const AtomicStruct& atomj) const
{
if (atomi.NumOfAtoms() > 1 || atomj.NumOfAtoms() > 1){
throw invalid_argument("TISurfHamGen(): atomi and atomj must should contain one atom each.");
}
int noi = atomi.NumOfOrbitals();
int noj = atomj.NumOfOrbitals();
cxmat smat = zeros<cxmat>(noi, noj);
// calculate distance between atom i and atom j
double xi = atomi.X(0), yi = atomi.Y(0), zi = atomi.Z(0);
double xj = atomj.X(0), yj = atomj.Y(0), zj = atomj.Z(0);
double dx = abs(xi - xj), dy = abs(yi - yj), dz = abs(zi - zj);
double d = sqrt(dx*dx + dy*dy + dz*dz);
// Assign the the matrix elements based on the distance between
// the lattice points.
if (atomi.Symbol(0) == "D" && atomj.Symbol(0) == "D"){
// site energy
if (d <= mdtol){
smat = mI;
}
}
return smat;
};
}}
| 28.179245 | 101 | 0.490793 | mirzaelahi |
b34f5322e95c6dfb58a48c59ca9a5609c89dfed7 | 821 | cpp | C++ | test/unit-XmlElementEmpty.cpp | Luchev/uni-xml-parser | 2a30d317617a19dd0c34b1788e478bd777f218ac | [
"MIT"
] | null | null | null | test/unit-XmlElementEmpty.cpp | Luchev/uni-xml-parser | 2a30d317617a19dd0c34b1788e478bd777f218ac | [
"MIT"
] | null | null | null | test/unit-XmlElementEmpty.cpp | Luchev/uni-xml-parser | 2a30d317617a19dd0c34b1788e478bd777f218ac | [
"MIT"
] | null | null | null | #include <lib/catch.hpp>
#include <test/test-utilities.hpp>
#include <test/test-XmlElementEmpty.hpp>
TEST_CASE("XmlElement set/getName() correctness", "[xmlElement]") {
REQUIRE(testXmlElementEmptyName());
}
TEST_CASE("XmlElement set/getParent() correctness", "[xmlElement]") {
REQUIRE(testXmlElementEmptyParent());
}
TEST_CASE("XmlElement addAttribute() correctness", "[xmlElementEmpty]") {
REQUIRE(testXmlElementEmptyAddAttributeCountZero());
REQUIRE(testXmlElementEmptyAddAttributeCountOne());
REQUIRE(testXmlElementEmptyAddAttributeValueIsCorrect());
}
TEST_CASE("XmlElement toString() correctness", "[xmlElementEmpty]") {
REQUIRE(testXmlElementEmptyToStringNoAttributes());
REQUIRE(testXmlElementEmptyToStringOneAttribute());
REQUIRE(testXmlElementEmptyToStringTwoAttributes());
}
| 34.208333 | 73 | 0.774665 | Luchev |
b354d97c0d2b93694906a10965ca1bd3eb263aa2 | 1,009 | cpp | C++ | samples/bbcnews/app/ui/common/cell.cpp | reubenscratton/oaknut | 03b37965ad84745bd5c077a27d8b53d58a173662 | [
"MIT"
] | 5 | 2019-10-04T05:10:06.000Z | 2021-02-03T23:29:10.000Z | samples/bbcnews/app/ui/common/cell.cpp | reubenscratton/oaknut | 03b37965ad84745bd5c077a27d8b53d58a173662 | [
"MIT"
] | null | null | null | samples/bbcnews/app/ui/common/cell.cpp | reubenscratton/oaknut | 03b37965ad84745bd5c077a27d8b53d58a173662 | [
"MIT"
] | 2 | 2019-09-27T00:34:36.000Z | 2020-10-27T09:44:26.000Z | //
// BNCell.m
// BBCNews
//
// Copyright (c) 2014 BBC News. All rights reserved.
//
#include "cell.h"
#include "cellsmodule.h"
BNCell::BNCell(BNCellsModule *module) {
_module = module;
_usesScrollviewOffset = module->_usesScrollviewOffset;
COLOR color = _module->getBackgroundColor();
if (color) {
setBackgroundColor(color);
}
setLayoutSize(MEASURESPEC::Fill(), MEASURESPEC::Wrap());
}
void BNCell::setItem(BNItem* item) {
}
void BNCell::setRelationship(BNRelationship* rel) {
}
void BNCell::setPrefetchLevel(int prefetchLevel) {
_prefetchLevel = prefetchLevel;
}
void BNCell::layout(RECT constraint) {
View::layout(constraint);
}
void BNCell::setDummyInfo(const string& text) {
_isDummy = true;
}
//void BNCell::adviseScrollviewOffset(float offset) {
//}
void BNCell::onIsInitialContent() {
}
void BNCell::onSuperviewDidAppear(bool viewControllerIsMovingToParent) {
}
void BNCell::onSuperviewDidDisappear(bool viewControllerIsMovingFromParent) {
}
| 19.784314 | 77 | 0.717542 | reubenscratton |
b35502acb01046f23e2883a3f0e49e59f3efb63b | 62 | cpp | C++ | test/compile_include_rope_2.cpp | eightysquirrels/text | d935545648777786dc196a75346cde8906da846a | [
"BSL-1.0"
] | null | null | null | test/compile_include_rope_2.cpp | eightysquirrels/text | d935545648777786dc196a75346cde8906da846a | [
"BSL-1.0"
] | 1 | 2021-03-05T12:56:59.000Z | 2021-03-05T13:11:53.000Z | test/compile_include_rope_2.cpp | eightysquirrels/text | d935545648777786dc196a75346cde8906da846a | [
"BSL-1.0"
] | 3 | 2019-10-30T18:38:15.000Z | 2021-03-05T12:10:13.000Z | #include <boost/text/rope.hpp>
#include <boost/text/rope.hpp>
| 20.666667 | 30 | 0.741935 | eightysquirrels |
b355cbb861d608b3a68624748d2f081043b685b0 | 2,319 | hpp | C++ | Lib/Chip/Unknown/Holtek/ht32f275x/SysTick.hpp | cjsmeele/Kvasir | c8d2acd8313ae52d78259ee2d409b963925f77d7 | [
"Apache-2.0"
] | 376 | 2015-07-17T01:41:20.000Z | 2022-03-26T04:02:49.000Z | Lib/Chip/Unknown/Holtek/ht32f275x/SysTick.hpp | cjsmeele/Kvasir | c8d2acd8313ae52d78259ee2d409b963925f77d7 | [
"Apache-2.0"
] | 59 | 2015-07-03T21:30:13.000Z | 2021-03-05T11:30:08.000Z | Lib/Chip/Unknown/Holtek/ht32f275x/SysTick.hpp | cjsmeele/Kvasir | c8d2acd8313ae52d78259ee2d409b963925f77d7 | [
"Apache-2.0"
] | 53 | 2015-07-14T12:17:06.000Z | 2021-06-04T07:28:40.000Z | #pragma once
#include <Register/Utility.hpp>
namespace Kvasir {
//SysTick
namespace SystickCtrl{ ///<CTRL
using Addr = Register::Address<0xe000e010,0x0000fff8,0x00000000,unsigned>;
///ENABLE
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> enable{};
///TICKINT
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> tickint{};
///CLKSOURCE
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,unsigned> clksource{};
///COUNTFLAG
constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,unsigned> countflag{};
///Reserved.
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,17),Register::ReadWriteAccess,unsigned> reserved{};
}
namespace SystickLoad{ ///<LOAD
using Addr = Register::Address<0xe000e014,0x00000000,0x00000000,unsigned>;
///RELOAD
constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,0),Register::ReadWriteAccess,unsigned> reload{};
///Reserved.
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,24),Register::ReadWriteAccess,unsigned> reserved{};
}
namespace SystickVal{ ///<VAL
using Addr = Register::Address<0xe000e018,0x00000000,0x00000000,unsigned>;
///CURRENT
constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,0),Register::ReadWriteAccess,unsigned> current{};
///Reserved.
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,24),Register::ReadWriteAccess,unsigned> reserved{};
}
namespace SystickCalib{ ///<CALIB
using Addr = Register::Address<0xe000e01c,0x3f000000,0x00000000,unsigned>;
///TENMS
constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,0),Register::ReadWriteAccess,unsigned> tenms{};
///SKEW
constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::ReadWriteAccess,unsigned> skew{};
///NOREF
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> noref{};
}
}
| 55.214286 | 127 | 0.705476 | cjsmeele |
b3575e393c46637c841f1391fa2098df614b9f65 | 120,472 | cpp | C++ | src/campaign/camptool/campdriv.cpp | Terebinth/freefalcon-central | c28d807183ab447ef6a801068aa3769527d55deb | [
"BSD-2-Clause"
] | 117 | 2015-01-13T14:48:49.000Z | 2022-03-16T01:38:19.000Z | src/campaign/camptool/campdriv.cpp | darongE/freefalcon-central | c28d807183ab447ef6a801068aa3769527d55deb | [
"BSD-2-Clause"
] | 4 | 2015-05-01T13:09:53.000Z | 2017-07-22T09:11:06.000Z | src/campaign/camptool/campdriv.cpp | darongE/freefalcon-central | c28d807183ab447ef6a801068aa3769527d55deb | [
"BSD-2-Clause"
] | 78 | 2015-01-13T09:27:47.000Z | 2022-03-18T14:39:09.000Z | // 2001-10-25 MOVED BY S.G. To the top of the file, outside of the #ifdef CAMPTOOL since it is used by other files as well
#ifdef _DEBUG
int gDumping = 0;
#endif
#ifdef CAMPTOOL
#include <windows.h>
#include <ctype.h>
#include "FalcLib.h"
#include "fsound.h"
#include "F4Vu.h"
#include "FalcSess.h"
#include "stdhdr.h"
#include "debuggr.h"
#include "camplib.h"
#include "camp2sim.h"
#include "threadmgr.h"
#include "cmpglobl.h"
#include "math.h"
#include "time.h"
#include "errorLog.h"
#include "campdisp.h"
#include "wingraph.h"
#include "Weather.h"
#include "dialog.h"
#include "uiwin.h"
#include "resource.h"
#include "unitdlg.h"
#include "falcmesg.h"
#include "campdriv.h"
#include "cmpevent.h"
#include "team.h"
#include "PlayerOp.h"
#include "ThreadMgr.h"
#include "classtbl.h"
// Campaign Specific Includes
#include "campaign.h"
#include "path.h"
#include "listADT.h"
#include "find.h"
#include "strategy.h"
#include "update.h"
#include "atm.h"
#include "gtm.h"
#include "CampList.h"
#include "CmpClass.h"
#include "CampBase.h"
#include "Convert.h"
#include "CampStr.h"
#include "CampMap.h"
#include "Options.h"
#include "CmpRadar.h"
#include "Graphics/Include/TMap.h"
// ========================================
// Global Variables
// ========================================
// Map sizing Info
#define MAX_XPIX 1536
#define MAX_YPIX 768
// Mapping data
MapData MainMapData;
int MaxXSize;
int MaxYSize;
unsigned char ReBlt = FALSE;
// Windows global handles
HWND hMainWnd = NULL, hToolWnd = NULL;
HDC hMainDC, hToolDC, hMapDC = NULL;
HMENU hMainMenu;
HBITMAP hMapBM;
HCURSOR hCurWait, hCurPoint, hCur = NULL;
// Threads
static F4THREADHANDLE hCampaignThread;
static DWORD CampaignThreadID;
// CampTool Specific
unsigned char Drawing = FALSE;
unsigned char RoadsOn = TRUE;
unsigned char RailsOn = TRUE;
unsigned char PBubble = FALSE;
unsigned char PBubbleDrawn = FALSE;
unsigned char SuspendDraw = TRUE;
unsigned char ShowCodes = FALSE;
unsigned char RefreshAll = FALSE;
unsigned char ShowSearch = FALSE;
unsigned char FreshDraw = FALSE;
unsigned char Saved;
unsigned char StateEdit;
unsigned char Moving = FALSE;
unsigned char Linking = FALSE;
unsigned char LinkTool = FALSE;
unsigned char FindPath = FALSE;
unsigned char WPDrag = FALSE;
unsigned char ShowFlanks = FALSE;
unsigned char ShowPaths = FALSE;
Team ThisTeam = 0;
char Mode = 1, EditMode = 8;
char TempPriority, DrawRoad = 0, DrawRail = 0, ObjMode = 0;
short CellSize;
ReliefType DrawRelief = Flat;
CoverType DrawCover = Water;
int DrawWeather = 0;
int ShowReal = 1;
GridIndex CurX, CurY, CenX, CenY, Movx, Movy, PBx, PBy, Sel1X, Sel1Y, Sel2X, Sel2Y;
costtype cost;
CampaignState StateToEdit = NULL;
ObjectiveType TempType;
Objective OneObjective, FromObjective, ToObjective, Neighbor, GlobObj, DragObjective = NULL;
Unit OneUnit, MoveUnit, PathUnit, GlobUnit, WPUnit, DragUnit = NULL;
WORD CampHour, CampMinute, CampDay;
WayPoint GlobWP = NULL;
F4PFList GlobList;
short ptSelected = 0;
extern int asAgg;
// Returns upper left hand corner of Cell, in window pixel coordinates
#define POSX(X) (short)((X)*md->CellSize-md->PFX)
#define POSY(Y) (short)(md->PLY-(Y+1)*md->CellSize)
// For testing
unsigned char SHOWSTATS;
int NoInput = 1;
int gMoveFlags = PATH_ENEMYOK bitor PATH_ROADOK;
int gMoveType = Tracked;
int gMoveWho = 6;
extern BOOL WINAPI SelectSquadron(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
// Renaming tool stuff
VU_ID_NUMBER RenameTable[65536] = { 0 };
int gRenameIds = 0;
extern int displayCampaign;
extern int maxSearch;
extern void ShowMissionLists(void);
// 2001-10-25 MOVED BY S.G. To the top of the file, outside of the #ifdef CAMPTOOL since it is used by other files as well
//#ifdef _DEBUG
//int gDumping = 0;
//#endif
// ========================================
// Necessary Prototypes
// ========================================
LRESULT CALLBACK CampaignWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
void CampMain(HINSTANCE hInstance, int nCmdShow);
void ProcessCommand(int Key);
void SetRefresh(MapData md);
void GetCellScreenRect(MapData md, GridIndex X, GridIndex Y, RECT *r);
// ====================================================================
// Campaign Support Functions (These are called by the campaign itself)
// ====================================================================
void ReBltWnd(MapData md, HDC DC)
{
RECT r;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
BitBlt(md->hMapDC, r.left, r.top, r.right, r.bottom, DC, r.left, r.top, SRCCOPY);
// MonoPrint("blt to storage: %d,%d:%d,%d\n",r.left,r.top,r.right-r.left,r.bottom-r.top);
}
// This is a temporary routine for testing...
// Shows the pattern taken with my search routine.
void ShowWhere(MapData md, GridIndex x, GridIndex y, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetCellScreenRect(md, x, y, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
_rectangle(DC, _GFILLINTERIOR, POSX(x), POSY(y), POSX(x + 1), POSY(y + 1));
EndPaint(md->hMapWnd, &ps);
}
// Show the time
void ShowTime(CampaignTime t)
{
RECT r;
WORD nm, nh;
if ( not hToolWnd)
return;
while (t > CampaignDay)
t -= CampaignDay;
nh = (WORD)(t / CampaignHours);
nm = (WORD)((t - nh * CampaignHours) / CampaignMinutes);
if (nm not_eq CampMinute)
{
_setcolor(hToolDC, White);
CampHour = nh;
CampMinute = nm;
CampDay = (WORD)TheCampaign.GetCurrentDay();
GetClientRect(hToolWnd, &r);
InvalidateRect(hToolWnd, &r, FALSE);
PostMessage(hToolWnd, WM_PAINT, 0, 0);
}
}
void ShowLink(MapData md, Objective o, Objective n, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
GridIndex x, y;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
o->GetLocation(&x, &y);
_moveto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
n->GetLocation(&x, &y);
_lineto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
EndPaint(md->hMapWnd, &ps);
}
// Draw a waypoint box
void ShowWP(MapData md, GridIndex X, GridIndex Y, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetCellScreenRect(md, X, Y, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
_rectangle(DC, _GBORDER, POSX(X), POSY(Y), POSX(X) + md->CellSize * 4, POSY(Y) + md->CellSize * 4);
EndPaint(md->hMapWnd, &ps);
}
void ShowWPLeg(MapData md, GridIndex x, GridIndex y, GridIndex X, GridIndex Y, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
_moveto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
_lineto(DC, POSX(X) + (md->CellSize >> 1), POSY(Y) + (md->CellSize >> 1));
EndPaint(md->hMapWnd, &ps);
ShowWP(md, x, y, color);
ShowWP(md, X, Y, color);
}
void ShowPath(MapData md, GridIndex X, GridIndex Y, Path p, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
int i, d, step;
GridIndex x, y;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
_moveto(DC, POSX(X) + (md->CellSize >> 1), POSY(Y) + (md->CellSize >> 1));
if (QuickSearch)
step = QuickSearch;
else
step = 1;
for (i = 0; i < p->GetLength(); i++)
{
d = p->GetDirection(i);
if (d >= 0)
{
x = X + dx[d] * step;
y = Y + dy[d] * step;
_lineto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
X = x;
Y = y;
}
}
EndPaint(md->hMapWnd, &ps);
}
void ShowObjectivePath(MapData md, Objective o, Path p, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
int i, d;
GridIndex x, y;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
o->GetLocation(&x, &y);
_moveto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
for (i = 0; i < p->GetLength(); i++)
{
d = p->GetDirection(i);
if (d >= 0)
{
o = o->GetNeighbor(d);
o->GetLocation(&x, &y);
_lineto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
}
}
EndPaint(md->hMapWnd, &ps);
}
void ShowPathHistory(MapData md, GridIndex X, GridIndex Y, Path p, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
int i, d, step;
GridIndex x, y;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
_moveto(DC, POSX(X) + (md->CellSize >> 1), POSY(Y) + (md->CellSize >> 1));
i = 1;
if (QuickSearch)
step = QuickSearch;
else
step = 1;
d = p->GetPreviousDirection(i);
while (d not_eq Here)
{
x = X - dx[d] * step;
y = Y - dy[d] * step;
_lineto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
X = x;
Y = y;
i++;
}
EndPaint(md->hMapWnd, &ps);
}
void ShowRange(MapData md, GridIndex X, GridIndex Y, int range, int color)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
GridIndex x, y;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
_setcolor(DC, color);
range *= md->CellSize;
x = (short)(POSX(X) + (md->CellSize >> 1));
y = (short)(POSY(Y) + (md->CellSize >> 1));
_ellipse(DC, _GBORDER, x - range, y - range, x + range, y + range);
EndPaint(md->hMapWnd, &ps);
}
void ShowLinkCosts(Objective f, Objective t)
{
int i, j;
MonoPrint("Link Costs: ");
for (i = 0; i < f->NumLinks(); i++)
{
if (f->GetNeighbor(i) == t)
{
for (j = 0; j < MOVEMENT_TYPES; j++)
MonoPrint("%d ", f->link_data[i].costs[j]);
}
}
MonoPrint("\n");
}
void ShowDivisions(HDC DC, MapData md)
{
int t;
Division d;
Unit u;
for (t = 0; t < NUM_TEAMS; t++)
{
d = GetFirstDivision(t);
while (d)
{
u = d->GetFirstUnitElement();
while (u)
{
if (u->GetSType() == d->type)
{
DisplayUnit(DC, u, (short)(POSX(d->x - 2) + (md->CellSize >> 3) * 5), (short)(POSY(d->y + 2) + (md->CellSize >> 2) * 5), (short)(md->CellSize >> 1) * 5);
u = NULL;
}
else
u = d->GetNextUnitElement();
}
d = d->next;
}
}
}
void RedrawUnit(Unit u)
{
GridIndex x, y;
PAINTSTRUCT ps;
RECT r;
HDC DC;
MapData md = MainMapData;
if ( not MainMapData)
return;
u->GetLocation(&x, &y);
GetCellScreenRect(md, x, y, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
DisplayUnit(DC, u, (short)(POSX(x) + (md->CellSize >> 3)), (short)(POSY(y) + (md->CellSize >> 2)), (short)(md->CellSize >> 1));
EndPaint(md->hMapWnd, &ps);
}
// return 0 or 1 depending on if this unit is a type we want to display
int DisplayOk(Unit u)
{
if (ShowReal == 1 and u->Real() and not u->Inactive())
return 1;
else if ( not ShowReal and u->Parent() and not u->Inactive())
return 1;
else if (ShowReal == 2 and u->Inactive())
return 1;
return 0;
}
// ===============================================
// Mutual support functions
// ===============================================
void GetCellScreenRect(MapData md, GridIndex X, GridIndex Y, RECT *r)
{
if ( not md)
return;
r->left = POSX(X);
r->top = POSY(Y);
r->right = r->left + md->CellSize;
r->bottom = r->top + md->CellSize;
}
void RedrawCell(MapData md, GridIndex X, GridIndex Y)
{
RECT r;
PAINTSTRUCT ps;
Objective o;
Unit u = NULL;
HDC DC;
short scale = 1;
if ( not md)
md = MainMapData;
if ( not MainMapData)
return; // Map's not open
if (X < md->FX or X > md->LX or Y < md->FY or Y > md->LY)
return;
GetCellScreenRect(md, X, Y, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
DisplayCellData(DC, X, Y, POSX(X), POSY(Y), md->CellSize, Mode, RoadsOn, RailsOn);
o = GetObjectiveByXY(X, Y);
if (o)
{
DisplayObjective(DC, o, POSX(X), POSY(Y), md->CellSize);
}
if (ShowReal == 1)
u = FindUnitByXY(AllRealList, X, Y, 0);
else if ( not ShowReal)
{
u = FindUnitByXY(AllParentList, X, Y, 0);
scale = 3;
X--;
Y++;
}
else if (ShowReal == 2)
u = FindUnitByXY(InactiveList, X, Y, 0);
else
{
Division d;
d = FindDivisionByXY(X, Y);
if (d)
u = d->GetUnitElement(0);
X -= 2;
Y += 2;
scale = 5;
}
if (u)
DisplayUnit(DC, u, (short)(POSX(X) + (md->CellSize >> 3)*scale), (short)(POSY(Y) + (md->CellSize >> 2)*scale), (short)((md->CellSize >> 1)*scale));
EndPaint(md->hMapWnd, &ps);
}
// =======================================
// Tool support functions
// =======================================
void ShowEmitters(MapData md, HDC DC)
{
CampEntity e;
GridIndex x, y;
int range;
VuListIterator myit(EmitterList);
e = GetFirstEntity(&myit);
while (e)
{
range = e->GetDetectionRange(Air);
if (range > 0)
{
e->GetLocation(&x, &y);
DisplaySideRange(DC, e->GetOwner(), (short)(POSX(x) + (md->CellSize >> 1)), (short)(POSY(y) + (md->CellSize >> 1)), range * md->CellSize);
}
e = GetNextEntity(&myit);
}
}
void ShowSAMs(MapData md, HDC DC)
{
CampEntity e;
GridIndex x, y;
int range;
VuListIterator myit(AirDefenseList);
e = GetFirstEntity(&myit);
while (e)
{
if (md->SAMs == 1)
range = e->GetWeaponRange(Air);
else
range = e->GetWeaponRange(LowAir);
if (range > 0 and (e->IsObjective() or (e->GetDomain() not_eq DOMAIN_AIR and e->IsUnit() and not ((Unit)e)->Moving())))
{
e->GetLocation(&x, &y);
DisplaySideRange(DC, e->GetOwner(), (short)(POSX(x) + (md->CellSize >> 1)), (short)(POSY(y) + (md->CellSize >> 1)), range * md->CellSize);
}
e = GetNextEntity(&myit);
}
}
void ShowPlayerBubble(MapData md, HDC DC, int show_ok)
{
//GridIndex x=0,y=0;
//int bubble_size = 20; // This is actually a per-entity value
//if (FalconLocalSession->Camera(0)){
// // sfr: xy order
// ::vector pos = { FalconLocalSession->Camera(0)->XPos(), FalconLocalSession->Camera(0)->YPos() };
// ConvertSimToGrid(&pos, &x, &y );
// y = SimToGrid(FalconLocalSession->Camera(0)->XPos());
// x = SimToGrid(FalconLocalSession->Camera(0)->YPos());
//}
//else {
// show_ok = FALSE;
//}
//if (PBubbleDrawn){
// SetROP2(DC, R2_NOT);
// DisplaySideRange(
// DC,0,(short)(POSX(PBx)+(md->CellSize>>1)),(short)(POSY(PBy)+(md->CellSize>>1)),bubble_size*md->CellSize
// );
// DisplaySideRange(
// DC,0,(short)(POSX(PBx)+(md->CellSize>>1)),(short)(POSY(PBy)+(md->CellSize>>1)),1*md->CellSize
// );
// SetROP2(DC, R2_COPYPEN);
// PBubbleDrawn = FALSE;
//}
//if (show_ok){
// SetROP2(DC, R2_NOT);
// DisplaySideRange(
// DC,0,(short)(POSX(x)+(md->CellSize>>1)),(short)(POSY(y)+(md->CellSize>>1)),bubble_size*md->CellSize
// );
// DisplaySideRange(
// DC,0,(short)(POSX(x)+(md->CellSize>>1)),(short)(POSY(y)+(md->CellSize>>1)),1*md->CellSize
// );
// SetROP2(DC, R2_COPYPEN);
// PBubbleDrawn = TRUE;
// PBx = x;
// PBy = y;
//}
}
void RedrawPlayerBubble()
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
MapData md = MainMapData;
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
ShowPlayerBubble(md, DC, 1);
EndPaint(md->hMapWnd, &ps);
}
void ChangeCell(GridIndex X, GridIndex Y)
{
int i;//,x,y;
PAINTSTRUCT ps;
HDC DC;
RECT r;
MapData md = MainMapData;
Trim(&X, &Y);
switch (EditMode)
{
case 0:
case 1:
SetGroundCover(GetCell(X, Y), DrawCover);
break;
case 2:
SetReliefType(GetCell(X, Y), DrawRelief);
break;
case 3:
SetRoadCell(GetCell(X, Y), DrawRoad);
for (i = 0; i < 8; i++)
{
FreshDraw = TRUE;
RedrawCell(MainMapData, (short)(X + dx[i]), (short)(Y + dy[i]));
}
break;
case 4:
SetRailCell(GetCell(X, Y), DrawRail);
for (i = 0; i < 8; i++)
{
FreshDraw = TRUE;
RedrawCell(MainMapData, (short)(X + dx[i]), (short)(Y + dy[i]));
}
break;
case 5:
((WeatherClass*)realWeather)->SetCloudCover(X, Y, DrawWeather);
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
if (PBubble)
ShowPlayerBubble(md, DC, 0);
//JAM - FIXME
// for (x=X-FloatToInt32(CLOUD_CELL_SIZE); x<X+FloatToInt32(CLOUD_CELL_SIZE); x++)
// for (y=Y-FloatToInt32(CLOUD_CELL_SIZE); y<Y+FloatToInt32(CLOUD_CELL_SIZE); y++)
// DisplayCellData(DC,x,y,POSX(x),POSY(y),md->CellSize,Mode,0,0);
ReBltWnd(md, DC);
if (PBubble)
ShowPlayerBubble(md, DC, 1);
EndPaint(md->hMapWnd, &ps);
break;
case 6:
((WeatherClass*)realWeather)->SetCloudLevel(X, Y, DrawWeather);
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
DC = BeginPaint(md->hMapWnd, &ps);
if (PBubble)
ShowPlayerBubble(md, DC, 0);
//JAM - FIXME
// for (x=X-FloatToInt32(CLOUD_CELL_SIZE); x<X+FloatToInt32(CLOUD_CELL_SIZE); x++)
// for (y=Y-FloatToInt32(CLOUD_CELL_SIZE); y<Y+FloatToInt32(CLOUD_CELL_SIZE); y++)
// DisplayCellData(DC,x,y,POSX(x),POSY(y),md->CellSize,Mode,0,0);
ReBltWnd(md, DC);
if (PBubble)
ShowPlayerBubble(md, DC, 1);
EndPaint(md->hMapWnd, &ps);
break;
default:
break;
}
FreshDraw = TRUE;
RedrawCell(MainMapData, X, Y);
}
void ResizeCursor(void)
{
if (hCur)
DestroyCursor(hCur);
switch (CellSize)
{
case 2:
hCur = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR1));
break;
case 4:
hCur = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR2));
break;
case 8:
hCur = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR3));
break;
case 16:
hCur = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR4));
break;
default:
hCur = LoadCursor(hInst, MAKEINTRESOURCE(IDC_CURSOR0));
break;
}
SetCursor(hCur);
}
void FindBorders(MapData md)
{
RECT windim;
short xsize, ysize;
GridIndex tx, ty;
GetClientRect(md->hMapWnd, &windim);
xsize = (short)(windim.right); // - windim->left);
ysize = (short)(windim.bottom); // - windim->top);
tx = md->CenX - (xsize / md->CellSize) / 2;
ty = md->CenY + (ysize / md->CellSize) / 2;
if (tx - md->FX > 1 or md->FX - tx > 1)
md->FX = tx;
if (ty - md->LY > 1 or md->LY - ty > 1)
md->LY = ty;
md->LX = md->FX + (xsize / md->CellSize) + 1;
md->FY = md->LY - (ysize / md->CellSize) - 1;
if (md->LX > Map_Max_X)
{
md->LX = Map_Max_X;
md->FX = Map_Max_X - xsize / md->CellSize;
if (xsize / md->CellSize)
md->FX--;
}
if (md->LY > Map_Max_Y)
{
md->LY = Map_Max_Y;
md->FY = Map_Max_Y - ysize / md->CellSize;
}
if (md->FX < 0)
{
md->FX = 0;
md->LX = xsize / md->CellSize + 1;
}
if (md->FY < 0)
{
md->FY = 0;
md->LY = ysize / md->CellSize + 1;
}
if (md->LX > Map_Max_X)
md->LX = Map_Max_X;
if (md->LY > Map_Max_Y)
md->LY = Map_Max_Y;
md->PFX = md->FX * md->CellSize;
md->PLY = md->LY * md->CellSize;
md->PLX = md->PFX + xsize;
md->PFY = md->PLY - ysize;
md->CenX = CenX = (md->LX - md->FX) / 2 + md->FX;
md->CenY = CenY = (md->LY - md->FY) / 2 + md->FY;
GetWindowRect(md->hMapWnd, &windim);
md->WULX = (short)windim.left;
md->WULY = (short)windim.top;
md->CULX = GetSystemMetrics(SM_CXSIZEFRAME);
md->CULY = (SHORT)(windim.bottom - windim.top - ysize);
md->CULY -= GetSystemMetrics(SM_CYHSCROLL);
md->CULY -= GetSystemMetrics(SM_CYSIZEFRAME);
}
int CenPer(MapData md, GridIndex cen, int side)
{
RECT windim;
int size, range, per;
GetClientRect(md->hMapWnd, &windim);
if (side == XSIDE)
{
size = (short)(windim.right); // - windim->left);
range = 1 + Map_Max_X - (size / md->CellSize);
per = (cen - ((size / md->CellSize) / 2)) * 100 / range;
}
else
{
size = (short)(windim.bottom); // - windim->top);
range = 1 + Map_Max_Y - (size / md->CellSize);
per = ((Map_Max_Y - cen) - ((size / md->CellSize) / 2)) * 100 / range;
}
return per;
}
F4PFList GetSquadsFlightList(VU_ID id)
{
F4PFList list = new FalconPrivateList(&AllAirFilter);
Unit u;
VuListIterator myit(AllRealList);
list->Register();
u = GetFirstUnit(&myit);
while (u)
{
if (u->GetUnitParentID() == id and u->GetDomain() == DOMAIN_AIR and u->GetType() == TYPE_FLIGHT)
{
list->ForcedInsert(u);
}
u = GetNextUnit(&myit);
}
return list;
}
#define MAX_OBJ_TYPES 33 // WARNING: This should go someplace real...
typedef struct
{
short ClassId;
short stype;
} OBJ_DATA;
void MakeCampaignNew(void)
{
// Remove all flights, reset times, and generally do what is necessary
// to make a campaign be "unrun"
Unit u;
int i, id;
ATMAirbaseClass *cur;
// Clearup unit data
{
VuListIterator uit(AllUnitList);
u = (Unit)uit.GetFirst();
while (u)
{
if (u->IsFlight() or u->IsPackage())
{
u->KillUnit();
u->Remove();
}
else if (u->IsBattalion())
{
((Battalion)u)->SetUnitSupply(100);
((Battalion)u)->last_move = 0;
((Battalion)u)->last_combat = 0;
((Battalion)u)->SetSpottedTime(0);
((Battalion)u)->SetUnitFatigue(0);
((Battalion)u)->SetUnitMorale(100);
((Battalion)u)->SetFullStrength(0);
((Battalion)u)->last_obj = FalconNullId;
((Battalion)u)->deag_data = NULL;
((Battalion)u)->DisposeWayPoints();
((Battalion)u)->ClearUnitPath();
((Battalion)u)->SetOrders(0);
((Battalion)u)->SetPObj(FalconNullId);
((Battalion)u)->SetSObj(FalconNullId);
((Battalion)u)->SetAObj(FalconNullId);
}
else if (u->IsBrigade()/*u->IsBattalion()*/)
{
((Brigade)u)->SetFullStrength(0);
((Brigade)u)->SetOrders(0);
((Brigade)u)->SetPObj(FalconNullId);
((Brigade)u)->SetSObj(FalconNullId);
((Brigade)u)->SetAObj(FalconNullId);
}
else if (u->IsSquadron())
{
((Squadron)u)->SetUnitAirbase(FalconNullId);
for (i = 0; i < VEHICLE_GROUPS_PER_UNIT; i++)
((Squadron)u)->ClearSchedule(i);
((Squadron)u)->SetHotSpot(FalconNullId);
((Squadron)u)->SetAssigned(0);
for (i = 0; i < ARO_OTHER; i++)
((Squadron)u)->SetRating(i, 0);
((Squadron)u)->SetAAKills(0);
((Squadron)u)->SetAGKills(0);
((Squadron)u)->SetASKills(0);
((Squadron)u)->SetANKills(0);
((Squadron)u)->SetMissionsFlown(0);
((Squadron)u)->SetMissionScore(0);
((Squadron)u)->SetTotalLosses(0);
((Squadron)u)->SetPilotLosses(0);
for (i = 0; i < PILOTS_PER_SQUADRON; i++)
{
id = ((Squadron)u)->GetPilotData(i)->pilot_id;
// 2000-11-17 MODIFIED BY S.G. NEED TO PASS THE 'airExperience' OF THE TEAM SO I CAN USE IT AS A BASE
// ((Squadron)u)->GetPilotData(i)->ResetStats();
((Squadron)u)->GetPilotData(i)->ResetStats(TeamInfo[((Squadron)u)->GetOwner()]->airExperience);
((Squadron)u)->GetPilotData(i)->pilot_id = id;
}
}
u = (Unit)uit.GetNext();
}
}
// Clear team and planner data
for (i = 0; i < NUM_TEAMS; i++)
{
TeamInfo[i]->atm->squadrons = 0;
TeamInfo[i]->atm->requestList->Purge();
TeamInfo[i]->atm->delayedList->Purge();
TeamInfo[i]->atm->supplyBase = 0;
cur = TeamInfo[i]->atm->airbaseList;
while (cur)
{
cur->id = FalconNullId;
memset(cur->schedule, 0, sizeof(uchar)*ATM_MAX_CYCLES);
cur->usage = 0;
cur = cur->next;
}
}
// Clear campaign data
TheCampaign.lastGroundTask = 0;
TheCampaign.lastAirTask = 0;
TheCampaign.lastNavalTask = 0;
TheCampaign.lastGroundPlan = 0;
TheCampaign.lastAirPlan = 0;
TheCampaign.lastNavalPlan = 0;
TheCampaign.lastResupply = 0;
TheCampaign.lastRepair = 0;
TheCampaign.lastReinforcement = 0;
TheCampaign.lastStatistic = 0;
TheCampaign.lastMajorEvent = 0;
TheCampaign.last_victory_time = 0;
TheCampaign.TimeStamp = 0;
TheCampaign.CurrentDay = 0;
TheCampaign.FreeCampMaps();
}
void MatchObjectiveTypes(void)
{
char *file, buffer[80];
GridIndex x, y;
FILE *fp;
int i, j, k, TexIndex, id, set;
short *counts, type, index, matches;
ObjClassDataType* oc;
GridIndex *locs; //DSP
OBJ_DATA stypes[20];
memset(stypes, 0, sizeof(OBJ_DATA) * 20);
CampEnterCriticalSection();
fp = OpenCampFile("TypeErro", "too", "wb");
//FromObjective = GetFirstObjective(&oit);
counts = new short[(MaxTextureType + 1)*NumEntities];
memset(counts, 0, sizeof(short) * (MaxTextureType + 1)*NumEntities);
locs = new GridIndex[(MaxTextureType + 1)*NumEntities * 2]; //DSP
memset(locs, 0, sizeof(GridIndex) * (MaxTextureType + 1)*NumEntities * 2);
while (FromObjective not_eq NULL)
{
if (FromObjective->ManualSet())
{
// We want to leave this as we set it.
/*FromObjective = GetNextObjective(&oit);*/
continue;
}
FromObjective->GetLocation(&x, &y);
file = GetFilename(x, y);
file = strchr(file, '.') - 3;
TexIndex = GetTextureIndex(x, y);
j = i = 1;
set = 0;
matches = 0;
index = FromObjective->Type() - VU_LAST_ENTITY_TYPE;
type = FromObjective->GetType();
while (j)
{
j = GetClassID(DOMAIN_LAND, CLASS_OBJECTIVE, (uchar)type, i, 0, 0, 0, 0);
if (j)
{
oc = (ObjClassDataType*) Falcon4ClassTable[j].dataPtr;
if (oc and strncmp(oc->Name, file, 3) == 0)
{
//record values for matches, so we can choose later
stypes[matches].ClassId = j;
stypes[matches].stype = i;
matches++;
}
}
i++;
}
//if ( not set) // no matching texture
if ( not matches)
{
FromObjective->SetObjectiveSType(1);
index = GetClassID(DOMAIN_LAND, CLASS_OBJECTIVE, (uchar)type, 1, 0, 0, 0, 0);
counts[TexIndex * NumEntities + index]--;
locs[(TexIndex * NumEntities + index) * 2] = x; //DSP
locs[(TexIndex * NumEntities + index) * 2 + 1] = y;
}
else
{
//use number of matches found to randomly choose which values to use
id = rand() % matches;
FromObjective->SetObjectiveSType((uchar)stypes[id].stype);
index = stypes[id].ClassId;
memset(stypes, 0, sizeof(OBJ_DATA) * 20);
counts[TexIndex * NumEntities + index]++;
locs[(TexIndex * NumEntities + index) * 2] = x; //DSP
locs[(TexIndex * NumEntities + index) * 2 + 1] = y;
}
//FromObjective = GetNextObjective(&oit);
}
// Now output totals:
for (i = 1; i < MAX_OBJ_TYPES; i++)
{
j = index = 1;
while (index)
{
index = GetClassID(DOMAIN_LAND, CLASS_OBJECTIVE, (uchar)i, (uchar)j, 0, 0, 0, 0);
oc = (ObjClassDataType*) Falcon4ClassTable[index].dataPtr;
for (k = 0; k < MaxTextureType + 1 and index; k++)
{
if ( not counts[k * NumEntities + index])
continue;
file = GetTextureId(k);
if (counts[k * NumEntities + index] > 0)
sprintf(buffer, "%s - %s on texture %s: %d - x: %d y: %d\n", ObjectiveStr[i], oc->Name, file, counts[k * NumEntities + index], locs[(k * NumEntities + index) * 2], locs[(k * NumEntities + index) * 2 + 1]);
else if (counts[k * NumEntities + index] < 0 and index)
sprintf(buffer, "%s - %s on texture %s: %d - NEEDED x: %d y: %d\n", ObjectiveStr[i], oc->Name, file, -counts[k * NumEntities + index], locs[(k * NumEntities + index) * 2], locs[(k * NumEntities + index) * 2 + 1]); //DSP
fwrite(buffer, strlen(buffer), 1, fp);
}
j++;
}
}
delete [] locs ;
CloseCampFile(fp);
CampLeaveCriticalSection();
}
void RecalculateBrigadePositions(void)
{
Unit unit;
Unit battalion;
GridIndex x, y, SumX, SumY;
int count;
VuListIterator myit(AllParentList);
unit = (Unit) myit.GetFirst();
while (unit not_eq NULL)
{
SumX = SumY = count = 0;
if (unit->GetType() == TYPE_BRIGADE)
{
battalion = unit->GetFirstUnitElement();
while (battalion)
{
battalion->GetLocation(&x, &y);
SumX += x;
SumY += y;
count++;
battalion = unit->GetNextUnitElement();
}
if (count)
{
x = SumX / count;
y = SumY / count;
unit->SetLocation(x, y);
}
}
unit = (Unit) myit.GetNext();
}
}
void MoveUnits(void)
{
Unit unit;
int x, y, deltaX, deltaY;
int initX, endX, initY, endY;
deltaX = CurX - Sel1X;
deltaY = CurY - Sel1Y;
if (Sel1X < Sel2X)
{
initX = Sel1X;
endX = Sel2X;
}
else
{
initX = Sel2X;
endX = Sel1X;
}
if (Sel1Y < Sel2Y)
{
initY = Sel1Y;
endY = Sel2Y;
}
else
{
initY = Sel2Y;
endY = Sel1Y;
}
for (x = initX; x <= endX; x++)
{
for (y = initY; y <= endY; y++)
{
if (ShowReal == 2)
{
do
{
unit = FindUnitByXY(InactiveList, x, y, 0);
if (unit)
{
unit->SetLocation(x + deltaX, y + deltaY);
}
}
while (unit);
}
else
{
do
{
unit = FindUnitByXY(AllParentList, x, y, 0);
if (unit)
{
unit->SetLocation(x + deltaX, y + deltaY);
}
}
while (unit);
do
{
unit = FindUnitByXY(AllRealList, x, y, 0);
if (unit)
{
unit->SetLocation(x + deltaX, y + deltaY);
}
}
while (unit);
}
}
}
SetRefresh(MainMapData);
ptSelected = 0;
}
void RegroupBrigades(void)
{
Unit unit;
Unit battalion;
int x, y;
int initX, endX, initY, endY;
if (Sel1X < Sel2X)
{
initX = Sel1X;
endX = Sel2X;
}
else
{
initX = Sel2X;
endX = Sel1X;
}
if (Sel1Y < Sel2Y)
{
initY = Sel1Y;
endY = Sel2Y;
}
else
{
initY = Sel2Y;
endY = Sel1Y;
}
for (x = initX; x <= endX; x++)
{
for (y = initY; y <= endY; y++)
{
unit = FindUnitByXY(AllParentList, x, y, 0);
if (unit)
{
if (unit->GetType() == TYPE_BRIGADE)
{
battalion = unit->GetFirstUnitElement();
while (battalion)
{
battalion->SetLocation(x , y);
battalion = unit->GetNextUnitElement();
}
}
}
}
}
SetRefresh(MainMapData);
ptSelected = 0;
}
void AssignBattToBrigDiv(void)
{
Unit unit;
Unit battalion;
VuListIterator myit(AllParentList);
unit = (Unit) myit.GetFirst();
while (unit not_eq NULL)
{
if (unit->GetType() == TYPE_BRIGADE)
{
battalion = unit->GetFirstUnitElement();
while (battalion)
{
battalion->SetUnitDivision(((GroundUnitClass *)unit)->GetUnitDivision());
battalion = unit->GetNextUnitElement();
}
}
unit = (Unit) myit.GetNext();
}
}
void DeleteUnit(Unit unit)
{
if ( not unit)
return;
Unit E;
CampEnterCriticalSection();
E = unit->GetFirstUnitElement();
while (E)
{
unit->RemoveChild(E->Id());
vuDatabase->Remove(E);
E = unit->GetFirstUnitElement();
}
// Kill the unit
unit->KillUnit();
vuDatabase->Remove(unit);
// Remove parent, if we're the last element
E = unit->GetUnitParent();
if (E and not E->GetFirstUnitElement())
vuDatabase->Remove(E);
GlobUnit = NULL;
asAgg = 1;
CampLeaveCriticalSection();
}
void StartUnitEdit(void)
{
GridIndex X, Y;
X = (GridIndex) CurX;
Y = (GridIndex) CurY;
TheCampaign.Suspend();
if (ShowReal == 1)
OneUnit = FindUnitByXY(AllRealList, X, Y, 0);
else if (ShowReal == 0)
OneUnit = FindUnitByXY(AllParentList, X, Y, 0);
else if (ShowReal == 2)
OneUnit = FindUnitByXY(InactiveList, X, Y, 0);
else
OneUnit = NULL; // Can't edit divisions
if (OneUnit)
GlobUnit = OneUnit;
else
GlobUnit = NULL;
if (GlobUnit)
DialogBox(hInst, MAKEINTRESOURCE(IDD_UNITDIALOG1), hMainWnd, (DLGPROC)EditUnit);
if (MainMapData->ShowWPs)
SetRefresh(MainMapData);
else
{
InvalidateRect(MainMapData->hMapWnd, NULL, FALSE);
PostMessage(MainMapData->hMapWnd, WM_PAINT, (WPARAM)hMainDC, 0);
}
TheCampaign.Resume();
}
void StartObjectiveEdit(void)
{
GridIndex X, Y;
X = (GridIndex) CurX;
Y = (GridIndex) CurY;
CampEnterCriticalSection();
OneObjective = GetObjectiveByXY(X, Y);
if ( not OneObjective)
{
OneObjective = AddObjectiveToCampaign(X, Y);
}
GlobObj = OneObjective;
CampLeaveCriticalSection();
DialogBox(hInst, MAKEINTRESOURCE(IDD_OBJECTIVEDIALOG), hMainWnd, (DLGPROC)EditObjective);
MainMapData->ShowObjectives = TRUE;
InvalidateRect(MainMapData->hMapWnd, NULL, FALSE);
PostMessage(MainMapData->hMapWnd, WM_PAINT, (WPARAM)hMainDC, 0);
}
void DamageBattalions(void)
{
Unit unit;
int x, y;
int initX, endX, initY, endY;
if (Sel1X < Sel2X)
{
initX = Sel1X;
endX = Sel2X;
}
else
{
initX = Sel2X;
endX = Sel1X;
}
if (Sel1Y < Sel2Y)
{
initY = Sel1Y;
endY = Sel2Y;
}
else
{
initY = Sel2Y;
endY = Sel1Y;
}
for (x = initX; x <= endX; x++)
{
for (y = initY; y <= endY; y++)
{
unit = FindUnitByXY(AllRealList, x, y, 0);
if (unit)
{
if (unit->GetType() == TYPE_BATTALION)
{
}
}
}
}
SetRefresh(MainMapData);
ptSelected = 0;
}
void SetObjOwnersArea(int team)
{
Objective obj;
int x, y;
int initX, endX, initY, endY;
if (Sel1X < Sel2X)
{
initX = Sel1X;
endX = Sel2X;
}
else
{
initX = Sel2X;
endX = Sel1X;
}
if (Sel1Y < Sel2Y)
{
initY = Sel1Y;
endY = Sel2Y;
}
else
{
initY = Sel2Y;
endY = Sel1Y;
}
for (x = initX; x <= endX; x++)
{
for (y = initY; y <= endY; y++)
{
obj = GetObjectiveByXY(x, y);
if (obj)
{
obj->SetOwner(team);
}
}
}
SetRefresh(MainMapData);
ptSelected = 0;
}
// ===================================
// Timing functions
// ===================================
/*
ulong Camp_VU_clock(void)
{
return (ulong)clock*1000/CLK_TCK;
}
ulong Camp_VU_game_time(void)
{
return (ulong)(Camp_GetCurrentTime()*1000);
}
*/
// ====================================
// Map display functions
// ====================================
void SetRefresh(MapData md)
{
RECT r;
if ( not md or not md->hMapWnd)
return;
RefreshAll = TRUE;
ReBlt = TRUE;
GetClientRect(md->hMapWnd, &r);
InvalidateRect(md->hMapWnd, &r, FALSE);
PostMessage(md->hMapWnd, WM_PAINT, 0, 0);
SuspendDraw = TRUE;
}
void RefreshCampMap(void)
{
SetRefresh(MainMapData);
}
void RefreshMap(MapData md, HDC DC, RECT *rect)
{
GridIndex x, y, NFX = 0, NFY = 0, NLX = 0, NLY = 0;
int clipx, clipy, ysize;
RECT r;
GridIndex xx, yy;
int side = 0;
WayPoint w;
// if (SuspendDraw)
CampEnterCriticalSection();
if (RefreshAll)
{
SetCursor(hCurWait);
NFX = md->FX;
NFY = md->FY;
NLX = md->LX;
NLY = md->LY;
RefreshAll = FALSE;
}
else if (FreshDraw)
{
NFX = (GridIndex)(rect->left / CellSize) + md->FX;
NFY = (GridIndex)(rect->top / CellSize) + md->FY;
NLX = (GridIndex)(rect->right / CellSize) + md->FX + 1;
NLY = (GridIndex)(rect->bottom / CellSize) + md->FY + 1;
FreshDraw = FALSE;
}
else
{
SetCursor(hCurWait);
if (PBubble)
ShowPlayerBubble(md, DC, 0); // Undraw the player bubble
// Update what we can with our bmap
NFX = md->FX;
NFY = md->FY;
NLX = md->FX;
NLY = md->FY;
GetClientRect(md->hMapWnd, &r);
ysize = r.bottom;
if (md->PFX < md->PMFX)
{
NFX = md->FX;
NLX = (md->PMFX / md->CellSize) + 1;
NLY = md->LY;
r.left = md->PMFX - md->PFX;
side or_eq 1;
}
if (md->PFY < md->PMFY)
{
NFY = md->FY;
NLY = (md->PMFY / md->CellSize) + 1;
NLX = md->LX;
r.bottom = ysize - (md->PMFY - md->PFY);
side or_eq 2;
}
if (md->PLX > md->PMLX)
{
NLX = md->LX;
NFX = md->PMLX / md->CellSize;
NLY = md->LY;
r.right = md->PMLX - md->PFX;
side or_eq 4;
}
if (md->PLY > md->PMLY)
{
NLY = md->LY;
NFY = md->PMLY / md->CellSize;
NLX = md->LX;
r.top = ysize - (md->PMLY - md->PFY);
side or_eq 8;
}
if ((side bitand 0x5) == 0x5)
{
NFX = md->FX;
NLX = md->LX;
}
if ((side bitand 0xa) == 0xa)
{
NFY = md->FY;
NLY = md->LY;
}
if ((side bitand 0xC) == 0xC or (side bitand 0x3) == 0x3)
{
NFX = md->FX;
NFY = md->FY;
NLX = md->LX;
NLY = md->LY;
}
clipx = md->PFX - md->PMFX;
clipy = md->PMLY - md->PLY;
if (clipx < 0)
clipx = 0;
if (clipy < 0)
clipy = 0;
// Blit from storage to the screen
BitBlt(DC, r.left, r.top, r.right - r.left, r.bottom - r.top, md->hMapDC,
clipx, clipy, SRCCOPY);
if (NFX < md->FX)
NFX = md->FX;
if (NFY < md->FY)
NFY = md->FY;
if (NLX > md->LX)
NLX = md->LX;
if (NLY > md->LY)
NLY = md->LY;
}
// Now draw the rest.
for (y = NLY - 1; y >= NFY; y--)
for (x = NFX; x < NLX; x++)
DisplayCellData(DC, x, y, POSX(x), POSY(y), md->CellSize, Mode, RoadsOn, RailsOn);
PBubbleDrawn = FALSE;
// Reblt before drawing Objectives or Units - do that each time.
if (ReBlt)
ReBltWnd(md, DC);
md->PMFX = md->PFX;
md->PMLX = md->PLX;
md->PMFY = md->PFY;
md->PMLY = md->PLY;
if (md->ShowObjectives)
{
#ifdef VU_GRID_TREE_Y_MAJOR
VuGridIterator oit(ObjProxList, (BIG_SCALAR)GridToSim(md->CenX), (BIG_SCALAR)GridToSim(md->CenY), (BIG_SCALAR)GridToSim((short)(Distance(md->LX, md->LY, md->CenX, md->CenY))));
#else
VuGridIterator oit(ObjProxList, (BIG_SCALAR)GridToSim(md->CenY), (BIG_SCALAR)GridToSim(md->CenX), (BIG_SCALAR)GridToSim((short)(Distance(md->LX, md->LY, md->CenX, md->CenY))));
#endif
int i;
OneObjective = GetFirstObjective(&oit);
while (OneObjective not_eq NULL)
{
OneObjective->GetLocation(&x, &y);
if (x > md->LX or x < md->FX or y < md->FY or y > md->LY)
; // Out of window bounds
else
{
if (md->ShowLinks)
{
_setcolor(DC, White);
for (i = 0; i < OneObjective->NumLinks(); i++)
{
Neighbor = OneObjective->GetNeighbor(i);
if (Neighbor)
{
Neighbor->GetLocation(&xx, &yy);
_moveto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
_lineto(DC, POSX(xx) + (md->CellSize >> 1), POSY(yy) + (md->CellSize >> 1));
}
}
}
DisplayObjective(DC, OneObjective, POSX(x), POSY(y), md->CellSize);
}
OneObjective = GetNextObjective(&oit);
}
}
if (md->ShowUnits)
{
VuListIterator *uit = NULL;
short scale = 1, xd = 0, yd = 0;
if (ShowReal == 1)
uit = new VuListIterator(AllRealList);
else if ( not ShowReal)
{
uit = new VuListIterator(AllParentList);
scale = 3;
xd = -1;
yd = 1;
}
else if (ShowReal == 2)
uit = new VuListIterator(InactiveList);
else
ShowDivisions(DC, md);
if (uit)
{
OneUnit = GetFirstUnit(uit);
while (OneUnit not_eq NULL)
{
OneUnit->GetLocation(&x, &y);
DisplayUnit(DC, OneUnit, (short)(POSX(x + xd) + (md->CellSize >> 3)*scale), (short)(POSY(y + yd) + (md->CellSize >> 2)*scale), (short)((md->CellSize >> 1)*scale));
if (ShowPaths and OneUnit->IsBattalion())
{
if (OneUnit->GetType() == TYPE_BATTALION)
{
// sfr: this is pointer now... took out &
//ShowPath(md, x, y, &((Battalion)OneUnit)->path, White);
//ShowPathHistory(md, x, y, &((Battalion)OneUnit)->path, Red);
ShowPath(md, x, y, ((Battalion)OneUnit)->path, White);
ShowPathHistory(md, x, y, ((Battalion)OneUnit)->path, Red);
}
}
#ifdef USE_FLANKS
if (ShowFlanks and OneUnit->GetDomain() == DOMAIN_LAND)
{
GridIndex fx, fy;
OneUnit->GetLeftFlank(&fx, &fy);
_setcolor(DC, SideColor[OneUnit->GetOwner()]);
_moveto(DC, POSX(fx) + (md->CellSize >> 1), POSY(fy) + (md->CellSize >> 1));
_lineto(DC, POSX(x) + (md->CellSize >> 1), POSY(y) + (md->CellSize >> 1));
OneUnit->GetRightFlank(&fx, &fy);
_lineto(DC, POSX(fx) + (md->CellSize >> 1), POSY(fy) + (md->CellSize >> 1));
}
#endif
OneUnit = GetNextUnit(uit);
}
delete uit;
}
}
if (md->ShowWPs)
{
if ( not WPUnit or WPUnit->IsDead())
WPUnit = NULL;
else
{
WPUnit->GetLocation(&x, &y);
w = WPUnit->GetCurrentUnitWP();
while (w)
{
w->GetWPLocation(&xx, &yy);
ShowWPLeg(MainMapData, x, y, xx, yy, White);
w = w->GetNextWP();
x = xx;
y = yy;
}
}
}
if (md->Emitters)
{
ShowEmitters(md, DC);
}
if (md->SAMs)
{
ShowSAMs(md, DC);
}
if (PBubble)
ShowPlayerBubble(md, DC, 1);
SetCursor(hCur);
CampLeaveCriticalSection();
}
void zoomOut(MapData md)
{
md->CellSize /= 2;
if (md->CellSize < 1)
md->CellSize = 1;
CellSize = md->CellSize;
FindBorders(md);
MaxXSize = MAX_XPIX / md->CellSize;
MaxYSize = MAX_YPIX / md->CellSize;
SetRefresh(md);
ResizeCursor();
// nPos = (Map_Max_Y-md->CenY)*100/Map_Max_Y;
SetScrollPos(md->hMapWnd, SB_VERT, CenPer(MainMapData, CenY, YSIDE), TRUE);
// nPos = md->CenX*100/Map_Max_X;
SetScrollPos(md->hMapWnd, SB_HORZ, CenPer(MainMapData, CenX, XSIDE), TRUE);
}
void zoomIn(MapData md)
{
md->CellSize *= 2;
if (md->CellSize > 16)
md->CellSize = 16;
CellSize = md->CellSize;
FindBorders(md);
MaxXSize = MAX_XPIX / md->CellSize;
MaxYSize = MAX_YPIX / md->CellSize;
SetRefresh(md);
ResizeCursor();
// nPos = (Map_Max_Y-md->CenY)*100/Map_Max_Y;
SetScrollPos(md->hMapWnd, SB_VERT, CenPer(MainMapData, CenY, YSIDE), TRUE);
// nPos = md->CenX*100/Map_Max_X;
SetScrollPos(md->hMapWnd, SB_HORZ, CenPer(MainMapData, CenX, XSIDE), TRUE);
}
// ============================================
// Tool window procedure
// ============================================
LRESULT CALLBACK ToolWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT retval = 0;
switch (message)
{
case WM_PAINT:
{
char time[80], buffer[60];
RECT r;
PAINTSTRUCT ps;
HDC DC;
if (GetUpdateRect(hToolWnd, &r, FALSE))
{
DC = BeginPaint(hToolWnd, &ps);
/* sprintf(time,"Day %2.2d, %2.2d:%2.2d x%d ",CampDay, CampHour, CampMinute, gameCompressionRatio);*/
_moveto(DC, 1, 0);
_outgtext(DC, time);
// Theater Name
_moveto(DC, 190, 0);
_outgtext(DC, TheCampaign.TheaterName);
// Position
sprintf(time, "%d,%d ", CurX, CurY);
_moveto(DC, 1, 18);
_outgtext(DC, time);
// Texture file
if (ShowCodes)
{
char *file;
file = GetFilename(CurX, CurY);
sprintf(buffer, "%s ", file);
_moveto(DC, 190, 18);
_outgtext(DC, buffer);
}
if (OneObjective)
sprintf(time, "%s ", OneObjective->GetName(buffer, 60, FALSE));
else
sprintf(time, " ");
_moveto(DC, 1, 36);
_outgtext(DC, time);
if (OneUnit)
if (OneUnit->GetType() == TYPE_BATTALION and OneUnit->GetDomain() == DOMAIN_LAND)
{
if (((GroundUnitClass *)OneUnit)->GetDivision())
{
Unit unit;
unit = OneUnit->GetUnitParent();
if (unit)
sprintf(time, "%d-%d-%s ", ((GroundUnitClass *)OneUnit)->GetDivision(), unit->GetNameId(), OneUnit->GetName(buffer, 60, FALSE));
else
sprintf(time, "%d-%s ", ((GroundUnitClass *)OneUnit)->GetDivision(), OneUnit->GetName(buffer, 60, FALSE));
}
else
{
sprintf(time, "%s ", OneUnit->GetName(buffer, 60, FALSE));
}
}
else if (OneUnit->GetType() == TYPE_BRIGADE and OneUnit->GetDomain() == DOMAIN_LAND)
{
if (((GroundUnitClass *)OneUnit)->GetDivision())
{
sprintf(time, "%d-%s ", ((GroundUnitClass *)OneUnit)->GetDivision(), OneUnit->GetName(buffer, 60, FALSE));
}
else
{
sprintf(time, "%s ", OneUnit->GetName(buffer, 60, FALSE));
}
}
else
{
sprintf(time, "%s ", OneUnit->GetName(buffer, 60, FALSE));
}
else
sprintf(time, " ");
_moveto(DC, 1, 54);
_outgtext(DC, time);
if (Linking)
sprintf(time, "Linking..");
else if (LinkTool and FromObjective)
sprintf(time, "Linking #%d ", FromObjective->GetCampID());
else
sprintf(time, " ");
_moveto(DC, 1, 72);
_outgtext(DC, time);
EndPaint(hToolWnd, &ps);
}
retval = 0;
break;
}
case WM_DESTROY:
hToolWnd = NULL;
retval = DefWindowProc(hwnd, message, wParam, lParam);
break;
default:
retval = DefWindowProc(hwnd, message, wParam, lParam);
break;
}
return retval;
}
// ================================================
// Main Campaign Window procedure
// ================================================
BOOL MainWndCommandProc(HWND hWndFrame, WPARAM wParam, LONG lParam)
{
lParam = lParam;
switch (wParam)
{
case ID_FILE_NEWTHEATER:
InitTheaterTerrain();
((WeatherClass*)realWeather)->Init();
// WARNING: Things could get fucked if we changed the theater size
// DisposeProxLists();
// InitProximityLists();
// WARNING: entities will not be reinserted into prox lists
SetRefresh(MainMapData);
break;
case ID_FILE_OPENTHEATER:
OpenTheaterFile(hMainWnd);
((WeatherClass*)realWeather)->Init();
// WARNING: Things could get fucked if we changed the theater size
// DisposeProxLists();
// InitProximityLists();
// WARNING: entities will not be reinserted into prox lists
SetRefresh(MainMapData);
break;
case ID_FILE_SAVETHEATER:
// SaveTheaterFile(hMainWnd);
break;
case ID_FILE_SAVEASTHEATER:
SaveAsTheaterFile(hMainWnd);
break;
case ID_FILE_EXIT:
PostQuitMessage(0);
break;
case ID_EDIT_COVER:
EditMode = 0;
break;
case ID_EDIT_RELIEF:
EditMode = 2;
break;
case ID_EDIT_ROADS:
EditMode = 3;
DrawRoad = 1;
break;
case ID_EDIT_RAILS:
EditMode = 4;
DrawRail = 1;
break;
case ID_EDIT_WEATHER:
EditMode = 5;
DrawWeather = 1;
break;
case ID_EDIT_OBJECTIVES:
EditMode = 7;
MainMapData->ShowObjectives = 1;
break;
case ID_EDIT_UNITS:
EditMode = 8;
MainMapData->ShowUnits = 1;
case ID_EDIT_WATER:
DrawCover = Water;
break;
case ID_EDIT_BOG:
DrawCover = Bog;
break;
case ID_EDIT_BARREN:
DrawCover = Barren;
break;
case ID_EDIT_PLAINS:
DrawCover = Plain;
break;
case ID_EDIT_BRUSH:
DrawCover = Brush;
break;
case ID_EDIT_LFOREST:
DrawCover = LightForest;
break;
case ID_EDIT_HFOREST:
DrawCover = HeavyForest;
break;
case ID_EDIT_SURBAN:
DrawCover = Urban;
break;
case ID_EDIT_URBAN:
DrawCover = Urban;
break;
case ID_EDIT_FLAT:
DrawRelief = Flat;
break;
case ID_EDIT_ROUGH:
DrawRelief = Rough;
break;
case ID_EDIT_HILLY:
DrawRelief = Hills;
break;
case ID_EDIT_MOUNTAIN:
DrawRelief = Mountains;
break;
case ID_EDIT_CLEARCOV:
DrawWeather = 0;
break;
case ID_EDIT_LOWFOG:
DrawWeather = 1;
break;
case ID_EDIT_SCATTERED:
DrawWeather = 2;
break;
case ID_EDIT_BROKEN:
DrawWeather = 3;
break;
case ID_EDIT_OVERCAST:
DrawWeather = 4;
break;
case ID_EDIT_RAIN:
DrawWeather = 5;
break;
case ID_CAMPAIGN_NEW:
TheCampaign.Reset();
SetRefresh(MainMapData);
break;
case ID_CAMPAIGN_MAKENEW:
MakeCampaignNew();
break;
case ID_VIEW_ZOOMIN:
zoomIn(MainMapData);
break;
case ID_VIEW_ZOOMOUT:
zoomOut(MainMapData);
break;
case ID_VIEW_BOTH:
Mode = EditMode = 0;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_BOTH, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_COVER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RELIEF, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_CLOUDS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_LEVELS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_COVER:
Mode = EditMode = 1;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_BOTH, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_COVER, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RELIEF, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_CLOUDS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_LEVELS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_RELIEF:
Mode = EditMode = 2;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_BOTH, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_COVER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RELIEF, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_CLOUDS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_LEVELS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_CLOUDS:
Mode = EditMode = 5;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_BOTH, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_COVER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RELIEF, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_CLOUDS, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_LEVELS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_LEVELS:
Mode = EditMode = 6;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_BOTH, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_COVER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RELIEF, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_CLOUDS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_LEVELS, MF_BYCOMMAND bitor MF_CHECKED);
SetRefresh(MainMapData);
case ID_VIEW_ROADS:
RoadsOn = not RoadsOn;
if (RoadsOn)
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_ROADS, MF_BYCOMMAND bitor MF_CHECKED);
else
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_ROADS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_RAILS:
RailsOn = not RailsOn;
if (RailsOn)
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RAILS, MF_BYCOMMAND bitor MF_CHECKED);
else
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_RAILS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_EMITTERS:
// MainMapData->Emitters = not MainMapData->Emitters;
Mode = 11;
if (MainMapData->Emitters)
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_EMITTERS, MF_BYCOMMAND bitor MF_CHECKED);
else
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_EMITTERS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_SAMS:
// MainMapData->SAMs = not MainMapData->SAMs;
Mode = 10;
if (MainMapData->SAMs)
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_SAMS, MF_BYCOMMAND bitor MF_CHECKED);
else
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_SAMS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_PLAYERBUBBLE:
PBubble = not PBubble;
if (PBubble)
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PLAYERBUBBLE, MF_BYCOMMAND bitor MF_CHECKED);
else
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PLAYERBUBBLE, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_OBJPRIORITY:
ObjMode = 1;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJOWNER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJPRIORITY, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJTYPE, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_OBJOWNER:
ObjMode = 0;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJOWNER, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJPRIORITY, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJTYPE, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_OBJTYPE:
ObjMode = 2;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJOWNER, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJPRIORITY, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_OBJTYPE, MF_BYCOMMAND bitor MF_CHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_REALUNITS:
ShowReal = 1;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REALUNITS, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PARENTUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REINFORCEMENTS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_DIVISIONS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_PARENTUNITS:
ShowReal = 0;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REALUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PARENTUNITS, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REINFORCEMENTS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_DIVISIONS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_DIVISIONS:
ShowReal = 3;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REALUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PARENTUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REINFORCEMENTS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_DIVISIONS, MF_BYCOMMAND bitor MF_CHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_REINFORCEMENTS:
ShowReal = 2;
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REALUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_PARENTUNITS, MF_BYCOMMAND bitor MF_UNCHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_REINFORCEMENTS, MF_BYCOMMAND bitor MF_CHECKED);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_DIVISIONS, MF_BYCOMMAND bitor MF_UNCHECKED);
SetRefresh(MainMapData);
break;
case ID_VIEW_TEXTURECODES:
if (ShowCodes)
{
ShowCodes = 0;
CleanupConverter();
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_TEXTURECODES, MF_BYCOMMAND bitor MF_UNCHECKED);
}
else
{
ShowCodes = 1;
InitConverter(TheCampaign.TheaterName);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_TEXTURECODES, MF_BYCOMMAND bitor MF_CHECKED);
}
break;
case ID_VIEW_REFRESH:
SetRefresh(MainMapData);
break;
case ID_TOOLS_RECALULATELINKS:
{
int i, done;
PathClass path;
MSG msg;
GridIndex ox, oy;
// KCK: First, I need to place roads to ports
{
VuListIterator oit(AllObjList);
FromObjective = GetFirstObjective(&oit);
while (FromObjective not_eq NULL)
{
if (FromObjective->GetType() == TYPE_PORT)
{
FromObjective->GetLocation(&ox, &oy);
SetRoadCell(GetCell(ox, oy), 1);
// Attempt to find an adjacent land space
for (i = 0, done = 0; i < 8 and not done; i += 2)
{
if (GetCover(ox + dx[i], oy + dy[i]) not_eq Water)
{
SetRoadCell(GetCell(ox + dx[i], oy + dy[i]), 1);
done = 1;
}
}
// Attempt to find a diagonal if no luck
for (i = 1; i < 8 and not done; i += 2)
{
if (GetCover(ox + dx[i], oy + dy[i]) not_eq Water)
{
SetRoadCell(GetCell(ox + dx[i], oy + dy[i]), 1);
SetRoadCell(GetCell(ox + dx[i - 1], oy + dy[i - 1]), 1);
done = 1;
}
}
}
FromObjective = GetNextObjective(&oit);
}
}
// Next, do the linking
LinkTool = TRUE;
// CampEnterCriticalSection();
memset(CampSearch, 0, sizeof(uchar)*MAX_CAMP_ENTITIES);
/* FromObjective = GetFirstObjective(&oit);*/
while (FromObjective not_eq NULL)
{
CampSearch[FromObjective->GetCampID()] = 1;
for (i = 0; i < FromObjective->NumLinks(); i++)
{
ToObjective = FromObjective->GetNeighbor(i);
if (ToObjective and not CampSearch[ToObjective->GetCampID()])
LinkCampaignObjectives(&path, FromObjective, ToObjective);
}
/* FromObjective = GetNextObjective(&oit);*/
// Still handle window messages while we loop
if (GetMessage(&msg, NULL, 0, 0))
DispatchMessage(&msg); // Dispatch message to window.
}
// CampLeaveCriticalSection();
LinkTool = FALSE;
}
break;
case ID_TOOLS_SETOBJTYPES:
if ( not ShowCodes)
{
// Load the texture codes
ShowCodes = 1;
InitConverter(TheCampaign.TheaterName);
CheckMenuItem(GetMenu(hMainWnd), ID_VIEW_TEXTURECODES, MF_BYCOMMAND bitor MF_CHECKED);
}
MatchObjectiveTypes();
break;
case ID_TOOLS_OUTPUTREINFORCEMENTS:
{
GridIndex x, y;
FILE *fp;
Unit unit;
Unit brigade;
Objective obj;
char buffer[60], domain[8], type[12], div[5], brig[5], vehicle[20], objective[40];
CampEnterCriticalSection();
fp = OpenCampFile("Reinloc", "txt", "w");
if (fp)
{
VuListIterator myit(InactiveList);
unit = (Unit) myit.GetFirst();
while (unit not_eq NULL)
{
unit->GetLocation(&x, &y);
obj = GetObjectiveByXY(x, y);
if (obj)
{
sprintf(objective, "%s", obj->GetName(buffer, 60, FALSE));
}
else
{
strcpy(objective, "none");
}
if (unit->GetDomain() == DOMAIN_AIR)
{
strcpy(domain, "AIR");
if (unit->GetType() == TYPE_SQUADRON)
{
strcpy(div, "n/a");
strcpy(brig, "n/a");
strcpy(type, "SQUADRON");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
}
}
else if (unit->GetDomain() == DOMAIN_SEA)
{
strcpy(domain, "SEA");
if (unit->GetType() == TYPE_TASKFORCE)
{
strcpy(div, "n/a");
strcpy(brig, "n/a");
strcpy(type, "TASKFORCE");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
}
}
else if (unit->GetDomain() == DOMAIN_LAND)
{
strcpy(domain, "LAND");
if (unit->GetType() == TYPE_BRIGADE)
{
sprintf(div, "%d", ((GroundUnitClass *)unit)->GetDivision());
strcpy(brig, "n/a");
strcpy(type, "BRIGADE");
strcpy(vehicle, "n/a");
}
else if (unit->GetType() == TYPE_BATTALION)
{
brigade = unit->GetUnitParent();
if (brigade)
sprintf(brig, "%d", brigade->GetNameId());
else
strcpy(brig, "--");
sprintf(div, "%d", ((GroundUnitClass *)unit)->GetDivision());
strcpy(type, "BATTALION");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
}
}
fprintf(fp, "%d : %-4s : %-8s : %-5s : %-4s : %-4s : %-15s : %-20s : x : %d : y : %d : %s \n",
unit->GetReinforcement(), Side[unit->GetOwner()], domain, type, div, brig, unit->GetName(buffer, 60, FALSE), vehicle, (int)x, (int)y, objective);
unit = (Unit) myit.GetNext();
}
CloseCampFile(fp);
}
CampLeaveCriticalSection();
}
break;
case ID_TOOLS_OUTPUTUNITLOCATIONS:
{
GridIndex x, y;
FILE *fp;
Unit unit;
Unit brigade;
Objective obj;
char buffer[60], domain[8], type[12], div[5], brig[5], vehicle[20], objective[40];
CampEnterCriticalSection();
fp = OpenCampFile("Unitloc", "txt", "w");
if (fp)
{
VuListIterator myit(AllUnitList);
unit = (Unit) myit.GetFirst();
while (unit not_eq NULL)
{
unit->GetLocation(&x, &y);
obj = GetObjectiveByXY(x, y);
if (obj)
sprintf(objective, "%s", obj->GetName(buffer, 60, FALSE));
else
strcpy(objective, "none");
if (unit->GetDomain() == DOMAIN_AIR)
{
strcpy(domain, "AIR");
if (unit->GetType() == TYPE_SQUADRON)
{
strcpy(div, "n/a");
strcpy(brig, "n/a");
strcpy(type, "SQUADRON");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
//cur = DistanceToFront(x,y);
//min = u->GetUnitRange() / 50;
//max = u->GetUnitRange() / 4;
}
}
else if (unit->GetDomain() == DOMAIN_SEA)
{
strcpy(domain, "SEA");
if (unit->GetType() == TYPE_TASKFORCE)
{
strcpy(div, "n/a");
strcpy(brig, "n/a");
strcpy(type, "TASKFORCE");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
}
}
else if (unit->GetDomain() == DOMAIN_LAND)
{
strcpy(domain, "LAND");
if (unit->GetType() == TYPE_BRIGADE)
{
sprintf(div, "%d", ((GroundUnitClass *)unit)->GetDivision());
strcpy(brig, "n/a");
strcpy(type, "BRIGADE");
strcpy(vehicle, "n/a");
}
else if (unit->GetType() == TYPE_BATTALION)
{
brigade = unit->GetUnitParent();
if (brigade)
sprintf(brig, "%d", brigade->GetNameId());
else
strcpy(brig, "--");
sprintf(div, "%d", ((GroundUnitClass *)unit)->GetDivision());
strcpy(type, "BATTALION");
strcpy(vehicle, GetVehicleName(unit->GetVehicleID(0)));
}
}
fprintf(fp, "%-4s : %-8s : %-5s : %-4s : %-4s : %-15s : %-20s : x : %d : y : %d : %s : %d\n",
Side[unit->GetOwner()], domain, type, div, brig, unit->GetName(buffer, 60, FALSE), vehicle, (int)x, (int)y, objective, unit->Type());
unit = (Unit) myit.GetNext();
}
CloseCampFile(fp);
}
CampLeaveCriticalSection();
}
break;
case ID_TOOLS_OUTPUTOBJLOCATIONS:
{
uchar *objmap, type;
GridIndex x, y;
FILE *fp;
ObjClassDataType* oc;
char *file;
char buffer[60];
InitConverter(TheCampaign.TheaterName);
// This outputs two files - a text file and a raw file with
// objective placement info.
CampEnterCriticalSection();
fp = OpenCampFile("Objloc", "txt", "w");
if ( not fp)
{
CampLeaveCriticalSection();
break;
}
objmap = new unsigned char[Map_Max_X * Map_Max_Y];
memset(objmap, 255, sizeof(uchar)*Map_Max_X * Map_Max_Y);
type = 1;
// Collect data and print text file
while (type <= NumObjectiveTypes)
{
VuListIterator oit(AllObjList);
FromObjective = GetFirstObjective(&oit);
while (FromObjective not_eq NULL)
{
if (FromObjective->GetType() == type)
{
FromObjective->GetLocation(&x, &y);
file = GetFilename(x, y);
objmap[((Map_Max_Y - y - 1)*Map_Max_X) + x] = type;
oc = (ObjClassDataType*) Falcon4ClassTable[FromObjective->Type() - VU_LAST_ENTITY_TYPE].dataPtr;
if (oc)
fprintf(fp, "%-4s : %-15s : %-15s : %-20s : on : %-14s : at x: %4d : y: %4d : %d : %d\n",
Side[FromObjective->GetOwner()], ObjectiveStr[type], oc->Name, FromObjective->GetName(buffer, 60, FALSE), file, y, x, FromObjective->GetObjectivePriority(), FromObjective->GetCampId());
}
FromObjective = GetNextObjective(&oit);
}
type++;
}
CloseCampFile(fp);
// Now dump the RAW file
fp = OpenCampFile("Objloc", "raw", "wb");
fwrite(objmap, sizeof(uchar), Map_Max_X * Map_Max_Y, fp);
CloseCampFile(fp);
delete [] objmap;
CampLeaveCriticalSection();
}
break;
case ID_TOOLS_APPLYFORCERATIOS:
DialogBox(hInst, MAKEINTRESOURCE(IDD_FORCERARIODIALOG), hMainWnd, (DLGPROC)AdjustForceRatioProc);
AdjustForceRatios();
break;
case ID_TOOLS_CLIPCAMPAIGN:
DialogBox(hInst, MAKEINTRESOURCE(IDD_CAMP_CLIPPER), hMainWnd, (DLGPROC)CampClipperProc);
break;
case ID_TOOLS_AUTOSETSAMARTSITES:
{
GridIndex x, y;
float rel;
CampEnterCriticalSection();
{
VuListIterator oit(AllObjList);
FromObjective = GetFirstObjective(&oit);
while (FromObjective)
{
// SAM Site logic
if (FromObjective->GetType() == TYPE_AIRBASE or
FromObjective->GetType() == TYPE_ARMYBASE or
FromObjective->GetType() == TYPE_PORT or
FromObjective->GetType() == TYPE_FACTORY or
FromObjective->GetType() == TYPE_NUCLEAR or
FromObjective->GetType() == TYPE_POWERPLANT or
FromObjective->GetType() == TYPE_REFINERY or
FromObjective->GetType() == TYPE_CHEMICAL or
FromObjective->GetType() == TYPE_COM_CONTROL or
FromObjective->GetType() == TYPE_DEPOT or
FromObjective->GetType() == TYPE_RADAR or
FromObjective->GetType() == TYPE_SAM_SITE)
FromObjective->SetSamSite(1);
else
FromObjective->SetSamSite(0);
// HART Site logic
if (FromObjective->GetType() == TYPE_HARTS or
FromObjective->GetType() == TYPE_HILL_TOP)
FromObjective->SetArtillerySite(1);
else
FromObjective->SetArtillerySite(0);
// Commando logic
if (FromObjective->GetType() == TYPE_AIRBASE)
FromObjective->SetCommandoSite(1);
else
FromObjective->SetCommandoSite(0);
// Radar logic
if (FromObjective->GetType() == TYPE_AIRBASE or
FromObjective->GetType() == TYPE_RADAR)
FromObjective->SetRadarSite(1);
else
FromObjective->SetRadarSite(0);
// Mountain/Flat site logic
FromObjective->GetLocation(&x, &y);
rel = ((float)(GetRelief(x, y) + GetRelief(x + 1, y) + GetRelief(x - 1, y) + GetRelief(x, y + 1) + GetRelief(x, y - 1))) / 5.0F;
if (rel > 2.0F)
{
FromObjective->SetMountainSite(1);
FromObjective->SetFlatSite(0);
}
else if (rel < 0.5F)
{
FromObjective->SetMountainSite(0);
FromObjective->SetFlatSite(1);
}
FromObjective = GetNextObjective(&oit);
}
}
CampLeaveCriticalSection();
}
break;
case ID_TOOLS_PREORDERSAMARTILLERY:
{
Unit u;
GridIndex x, y;
Objective o;
int role;
VuListIterator uit(AllUnitList);
u = (Unit) uit.GetFirst();
while (u)
{
if (u->IsBattalion())
{
role = u->GetUnitNormalRole();
if (role == GRO_FIRESUPPORT or role == GRO_AIRDEFENSE)
{
u->GetLocation(&x, &y);
o = FindNearestObjective(x, y, NULL);
if (o)
u->SetUnitOrders(GetGroundOrders(role), o->Id());
}
}
u = (Unit) uit.GetNext();
}
}
break;
case ID_TOOLS_CALCULATERADARARCS:
{
Objective o;
float ox, oy, oz, x, y, r;
float angle, ratio, max_ratio;
mlTrig sincos;
int arc;
CampEnterCriticalSection();
{
VuListIterator oit(AllObjList);
o = GetFirstObjective(&oit);
while (o)
{
if (o->SamSite() or o->RadarSite() or o->GetElectronicDetectionRange(LowAir) > 0)
{
// This place needs arc data
ox = o->XPos();
oy = o->YPos();
oz = TheMap.GetMEA(ox, oy);
if (o->static_data.radar_data)
delete o->static_data.radar_data;
o->static_data.radar_data = new RadarRangeClass;
for (arc = 0; arc < NUM_RADAR_ARCS; arc++)
{
// Find this arc's ratio
max_ratio = MINIMUM_RADAR_RATIO;
angle = arc * (360 / NUM_RADAR_ARCS) * DTR;
while (angle < (arc + 1) * (360 / NUM_RADAR_ARCS) * DTR)
{
// Trace a ray every 10 degrees
r = KM_TO_FT;
mlSinCos(&sincos, angle);
while (r * max_ratio < LOW_ALTITUDE_CUTOFF)
{
// Step one km at a time
x = ox + r * sincos.cos;
y = oy + r * sincos.sin;
ratio = (TheMap.GetMEA(x, y) - oz) / r;
if (ratio > max_ratio)
max_ratio = ratio;
r += KM_TO_FT;
}
angle += 10 * DTR;
}
o->static_data.radar_data->SetArcRatio(arc, max_ratio);
}
}
o = GetNextObjective(&oit);
}
}
CampLeaveCriticalSection();
}
break;
case ID_TOOLS_GENERATEPAKMAP:
{
uchar *data = NULL;
ulong size;
FILE *fp;
size = sizeof(uchar) * (Map_Max_X / 4) * (Map_Max_Y / 4);
RebuildObjectiveLists();
data = MakeCampMap(MAP_PAK_BUILD, data, 0);
fp = fopen("pakmap.raw", "wb");
if (fp)
{
fwrite(data, size, 1, fp);
fclose(fp);
}
delete data;
break;
}
case ID_HELP_ABOUTCAMPTOOL:
{
FARPROC lpProcAbout;
lpProcAbout = MakeProcInstance((FARPROC)About, hInst);
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTDIALOG), hMainWnd, (DLGPROC)lpProcAbout);
FreeProcInstance(lpProcAbout);
break;
}
case ID_PB_CENTERONPLAYERBUBBLE:
if (PBubble and FalconLocalSession->GetPlayerEntity())
{
TheCampaign.GetPlayerLocation(&MainMapData->CenX, &MainMapData->CenY);
SetRefresh(MainMapData);
}
break;
case ID_CAMP_REFRESHPB:
RedrawPlayerBubble();
break;
default:
return(FALSE);
}
return(TRUE);
}
LRESULT CALLBACK CampaignWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT retval = 0;
static int shifted;
HBITMAP OldMap;
switch (message)
{
case WM_CREATE:
MainMapData = new MapWindowType;
MainMapData->CellSize = CellSize;
MainMapData->hMapWnd = hwnd;
MainMapData->CenX = CenX;
MainMapData->CenY = CenY;
MainMapData->ShowUnits = TRUE;
MainMapData->ShowObjectives = TRUE;
MainMapData->ShowLinks = FALSE;
MainMapData->Emitters = FALSE;
MainMapData->ShowWPs = FALSE;
MainMapData->SAMs = FALSE;
hMainDC = GetDC(hMainWnd);
hMapBM = CreateCompatibleBitmap(hMainDC, MAX_XPIX, MAX_YPIX);
hMapDC = CreateCompatibleDC(hMainDC);
MainMapData->hMapDC = hMapDC;
OldMap = (HBITMAP)SelectObject(hMapDC, hMapBM);
DeleteObject(OldMap);
ResizeCursor();
// set up it's menu bar
EnableMenuItem(GetMenu(hMainWnd), ID_FILE_MYSAVE, MF_BYCOMMAND bitor MF_DISABLED);
if (hMainMenu = GetSubMenu(GetMenu(hMainWnd), 0))
DrawMenuBar(hMainWnd);
// Init my graphics pointers
_initgraphics(hMainDC);
ReBlt = TRUE;
SetRefresh(MainMapData);
retval = 0;
break;
case WM_HSCROLL:
{
WORD nPos, nScrollCode;
RECT r;
nScrollCode = (int) LOWORD(wParam); // scroll bar value
nPos = (short int) HIWORD(wParam); // scroll box position
if (nScrollCode == 4)
{
ReBlt = TRUE;
CenX = nPos * Map_Max_X / 100;
}
if (nScrollCode == SB_PAGELEFT)
{
ReBlt = TRUE;
CenX = MainMapData->FX - ((MainMapData->LX - MainMapData->FX) / 4);
if (CenX < 0)
CenX = 0;
}
if (nScrollCode == SB_PAGERIGHT)
{
ReBlt = TRUE;
CenX = MainMapData->LX + ((MainMapData->LX - MainMapData->FX) / 4);
if (CenX > Map_Max_X)
CenX = Map_Max_X;
}
if (nScrollCode == SB_LINELEFT)
{
ReBlt = TRUE;
CenX -= Map_Max_X / 100;
if (CenX < 0)
CenX = 0;
}
if (nScrollCode == SB_LINERIGHT)
{
ReBlt = TRUE;
CenX += Map_Max_X / 100 + 1;
if (CenX > Map_Max_X)
CenX = Map_Max_X;
}
if (ReBlt and nScrollCode not_eq 8)
{
MainMapData->CenX = CenX;
MainMapData->CenY = CenY;
GetClientRect(hMainWnd, &r);
InvalidateRect(hMainWnd, &r, FALSE);
// SetScrollPos(hMainWnd, SB_HORZ, nPos, TRUE);
}
break;
}
case WM_VSCROLL:
{
WORD nPos, nScrollCode;
RECT r;
nScrollCode = (int) LOWORD(wParam); // scroll bar value
nPos = (short int) HIWORD(wParam); // scroll box position
if (nScrollCode == 4)
{
ReBlt = TRUE;
CenY = Map_Max_Y - (nPos * Map_Max_Y / 100);
}
if (nScrollCode == SB_PAGELEFT)
{
ReBlt = TRUE;
CenY = MainMapData->LY + ((MainMapData->LY - MainMapData->FY) / 4);
if (CenY > Map_Max_Y)
CenY = Map_Max_Y;
}
if (nScrollCode == SB_PAGERIGHT)
{
ReBlt = TRUE;
CenY = MainMapData->FY - ((MainMapData->LY - MainMapData->FY) / 4);
if (CenY < 0)
CenY = 0;
}
if (nScrollCode == SB_LINELEFT)
{
ReBlt = TRUE;
CenY += Map_Max_Y / 100 + 1;
if (CenY > Map_Max_Y)
CenY = Map_Max_Y;
}
if (nScrollCode == SB_LINERIGHT)
{
ReBlt = TRUE;
CenY -= Map_Max_Y / 100;
if (CenY < 0)
CenY = 0;
}
if (ReBlt and nScrollCode not_eq 8)
{
MainMapData->CenX = CenX;
MainMapData->CenY = CenY;
GetClientRect(hMainWnd, &r);
InvalidateRect(hMainWnd, &r, FALSE);
}
break;
}
case WM_MOUSEMOVE:
{
WORD fwKeys, xPos, yPos, xn, yn;
static int coffx = 0, coffy = 0;
POINT pt;
RECT r;
fwKeys = wParam; // key flags
/*
if (fwKeys == MK_LBUTTON and Drawing)
{
xPos = LOWORD(lParam);
yPos = HIWORD(lParam);
ChangeCell((GridIndex)((xPos+PFX)/CellSize),(GridIndex)((PLY-yPos)/CellSize));
}
*/
GetCursorPos(&pt); // Get the real mouse position
pt.x += coffx; // Add old offset
pt.y += coffy;
xPos = (WORD)(pt.x - MainMapData->WULX - MainMapData->CULX); // Get position relative to client area
yPos = (WORD)(pt.y - MainMapData->WULY - MainMapData->CULY);
CurX = (WORD)(xPos + MainMapData->PFX) / MainMapData->CellSize; // Get grid location in Campaign terms
CurY = (MainMapData->PLY - 1 - yPos) / MainMapData->CellSize;
if (fwKeys == MK_LBUTTON and Drawing)
ChangeCell(CurX, CurY);
coffx = xPos % CellSize; // Find our offset, if any
coffy = yPos % CellSize;
xn = (WORD) pt.x - coffx; // Find new grid location to snap to.
yn = (WORD) pt.y - coffy;
SetCursor(hCur);
SetCursorPos(xn, yn); // Snap to the grid
retval = 0;
OneObjective = GetObjectiveByXY(CurX, CurY);
if (ShowReal == 1)
OneUnit = FindUnitByXY(AllRealList, CurX, CurY, 0);
else if (ShowReal == 0)
OneUnit = FindUnitByXY(AllParentList, CurX, CurY, 0);
else if (ShowReal == 2)
{
OneUnit = FindUnitByXY(InactiveList, CurX, CurY, 0);
/* if (OneUnit and not OneUnit->Real())
{
int foundone=0;
GridIndex x,y;
Unit e;
VuListIterator myit(InactiveList);
// Next unit in stack.
e = (Unit) myit.GetFirst();
while (e and e not_eq OneUnit)
e = GetNextUnit(&myit); // Get to current location in list
// e should be OneUnit or be null here
if (e)
{
e = GetNextUnit(&myit);
while (e and not foundone)
{
e->GetLocation(&x,&y);
if (x==CurX and y==CurY and e not_eq OneUnit)
foundone = 1;
else
e = GetNextUnit(&myit);
}
}
OneUnit = e;
}
*/
}
else
OneUnit = NULL; // Can't edit divisions
// Post a message to Toolbar window to redraw (And show new x,y pos)
if (hToolWnd)
{
GetClientRect(hToolWnd, &r);
InvalidateRect(hToolWnd, &r, FALSE);
PostMessage(hToolWnd, WM_PAINT, 0, 0);
}
break;
}
case WM_KEYUP:
if ((int)wParam == 16)
shifted = FALSE;
retval = 0;
break;
case WM_KEYDOWN:
{
int C = (int)wParam;
if (C == 16)
shifted = TRUE;
//if(isalpha(C) and shifted)
//C += 0x20;
if (isalpha(C) and not (GetKeyState(VK_SHIFT) bitand 0x80))
C += 0x20;
ProcessCommand(C);
retval = 0;
break;
}
case WM_DESTROY :
ReleaseDC(hMainWnd, hMainDC);
DeleteDC(hMapDC);
DeleteObject(hMapBM);
_shutdowngraphics();
delete MainMapData;
if (ShowCodes)
{
CleanupConverter();
ShowCodes = FALSE;
}
displayCampaign = FALSE;
hMainWnd = NULL;
retval = 0;
break;
case WM_SIZE:
{
WORD nWidth, nHeight;
int trunc, resize = 0;
RECT r;
nWidth = LOWORD(lParam); // width of client area
nHeight = HIWORD(lParam); // height of client area
ReBlt = TRUE;
GetClientRect(hMainWnd, &r);
if (nWidth % 16 not_eq 0)
{
trunc = 1 + nWidth / 16;
r.right = 16 * trunc;
resize = 1;
if (r.right < 304)
r.right = 304;
}
if (nHeight % 16 not_eq 0)
{
if (r.right < 304)
r.right = 304;
trunc = 1 + nHeight / 16;
r.bottom = 16 * trunc;
resize = 1;
}
if (resize)
{
// Note: This should work, but currently doesnt. MSVC++ bug?
// AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW bitor WS_HSCROLL bitor WS_VSCROLL, TRUE);
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, TRUE);
r.right += GetSystemMetrics(SM_CXVSCROLL);
r.bottom += GetSystemMetrics(SM_CYHSCROLL);
SetWindowPos(hMainWnd, HWND_TOP, 0, 0, r.right - r.left, r.bottom - r.top, SWP_NOMOVE bitor SWP_NOZORDER);
PostMessage(hMainWnd, WM_PAINT, 0, 0);
}
else
PostMessage(hMainWnd, WM_PAINT, 0, 0);
retval = 0;
break;
}
case WM_MOVE:
FindBorders(MainMapData);
break;
case WM_ACTIVATE:
retval = 0;
if (LOWORD(wParam) == WA_INACTIVE)
ShowCursor(0);
else
ShowCursor(1);
break;
case WM_USER:
retval = 0;
break;
case WM_LBUTTONDOWN:
{
WORD fwKeys = wParam;
// if (fwKeys=MK_SHIFT)
// ;
if (MainMapData->ShowWPs and WPUnit)
{
WayPoint w;
GridIndex x, y;
w = WPUnit->GetFirstUnitWP();
while (w)
{
w->GetWPLocation(&x, &y);
if (x == CurX and y == CurY)
{
GlobWP = w;
WPDrag = TRUE;
}
w = w->GetNextWP();
}
}
else if (EditMode == 7)
{
DragObjective = OneObjective;
}
else if (EditMode == 8)
{
DragUnit = OneUnit;
}
else
{
ChangeCell(CurX, CurY);
Drawing = TRUE;
}
}
break;
case WM_LBUTTONUP:
Drawing = FALSE;
if (WPDrag)
{
WayPoint w;
GlobWP->SetWPLocation(CurX, CurY);
w = WPUnit->GetFirstUnitWP();
SetWPTimes(w, w->GetWPArrivalTime(), WPUnit->GetCruiseSpeed(), 0);
WPDrag = FALSE;
SetRefresh(MainMapData);
}
if (DragObjective)
{
DragObjective->SetLocation(CurX, CurY);
RecalculateLinks(DragObjective);
DragObjective = NULL;
SetRefresh(MainMapData);
}
if (DragUnit)
{
DragUnit->SetLocation(CurX, CurY);
DragUnit = NULL;
SetRefresh(MainMapData);
}
break;
case WM_RBUTTONDOWN:
{
switch (EditMode)
{
case 0:
case 1:
DrawCover = GetGroundCover(GetCell(CurX, CurY));
break;
case 2:
DrawRelief = GetReliefType(GetCell(CurX, CurY));
break;
case 3:
DrawRoad = GetRoadCell(GetCell(CurX, CurY));
break;
case 4:
DrawRail = GetRailCell(GetCell(CurX, CurY));
break;
case 5:
DrawWeather = ((WeatherClass*)realWeather)->GetCloudCover(CurX, CurY);
break;
case 6:
DrawWeather = ((WeatherClass*)realWeather)->GetCloudLevel(CurX, CurY);
break;
case 7:
StartObjectiveEdit();
break;
case 8:
StartUnitEdit();
break;
default:
break;
}
break;
}
case WM_PAINT:
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
if (GetUpdateRect(hMainWnd, &r, FALSE))
{
DC = BeginPaint(hMainWnd, &ps);
FindBorders(MainMapData);
SetScrollPos(hMainWnd, SB_HORZ, CenPer(MainMapData, CenX, XSIDE), TRUE);
SetScrollPos(hMainWnd, SB_VERT, CenPer(MainMapData, CenY, YSIDE), TRUE);
if (r.right > Map_Max_X * CellSize)
{
_setcolor(DC, Blue);
_rectangle(DC, _GFILLINTERIOR, Map_Max_X * CellSize, 0, r.right, r.bottom);
}
if (r.bottom > Map_Max_Y * CellSize)
{
_setcolor(DC, Blue);
_rectangle(DC, _GFILLINTERIOR, 0, Map_Max_Y * CellSize, r.right, r.bottom);
}
RefreshMap(MainMapData, DC, &r);
ReBlt = FALSE;
EndPaint(hMainWnd, &ps);
}
retval = 0;
break;
}
case WM_COMMAND:
MainWndCommandProc(hMainWnd, wParam, lParam);
break;
default:
retval = DefWindowProc(hwnd, message, wParam, lParam);
break;
}
return retval;
}
// ====================================
// Keyboard Command dispatch function
// ====================================
void ProcessCommand(int Key)
{
GridIndex X, Y, x, y;
int i;
X = (GridIndex) CurX;
Y = (GridIndex) CurY;
switch (Key)
{
case 'a':
CampEnterCriticalSection();
GlobUnit = AddUnit(X, Y, COUN_NORTH_KOREA);
CampLeaveCriticalSection();
DialogBox(hInst, MAKEINTRESOURCE(IDD_UNITDIALOG), hMainWnd, (DLGPROC)EditUnit);
if (GlobUnit)
GlobUnit = NULL;
MainMapData->ShowUnits = TRUE;
if (MainMapData->ShowWPs)
SetRefresh(MainMapData);
else
{
InvalidateRect(MainMapData->hMapWnd, NULL, FALSE);
PostMessage(MainMapData->hMapWnd, WM_PAINT, (WPARAM)hMainDC, 0);
}
Saved = FALSE;
break;
case 'A':
AssignBattToBrigDiv();
break;
case 'b':
SHOWSTATS = not SHOWSTATS;
break;
case 'B':
TheCampaign.MakeCampMap(MAP_SAMCOVERAGE);
TheCampaign.MakeCampMap(MAP_RADARCOVERAGE);
TheCampaign.MakeCampMap(MAP_OWNERSHIP);
// RecalculateBrigadePositions();
// SetRefresh(MainMapData);
break;
case 'c':
DialogBox(hInst, MAKEINTRESOURCE(IDD_WEATHERDIALOG), hMainWnd, (DLGPROC)WeatherEditProc);
break;
case 'C':
if (ptSelected == 2)
{
RegroupBrigades();
}
else
{
Sel1X = Sel2X = CurX;
Sel1Y = Sel2Y = CurY;
RegroupBrigades();
}
break;
case 'd':
gDumping = compl gDumping;
break;
case 'D':
DeleteUnit(OneUnit);
SetRefresh(MainMapData);
break;
case 'e':
DialogBox(hInst, MAKEINTRESOURCE(IDD_TEAMEDIT_DIALOG), hMainWnd, (DLGPROC)EditTeams);
break;
case 'E':
StateEdit = not StateEdit;
if (ThisTeam == 0 or not StateToEdit)
StateEdit = FALSE;
SetRefresh(MainMapData);
break;
case 'f':
break;
case 'F':
if (ShowFlanks)
ShowFlanks = 0;
else
ShowFlanks = 1;
SetRefresh(MainMapData);
break;
case 'G':
ptSelected = 0;
Sel1X = Sel2X = 0;
Sel1Y = Sel2Y = 0;
break;
case 'g':
if (ptSelected)
{
Sel2X = CurX;
Sel2Y = CurY;
ptSelected = 2;
}
else
{
Sel1X = CurX;
Sel1Y = CurY;
ptSelected = 1;
}
break;
case 'H':
// if (MainMapData->SAMs == 1)
// MainMapData->SAMs = 2;
// else if (MainMapData->SAMs == 2)
// MainMapData->SAMs = 1;
if (Mode == 10)
Mode = 11;
else if (Mode == 11)
Mode = 10;
SetRefresh(MainMapData);
break;
case 'l':
if (OneObjective)
{
if ( not Linking)
{
FromObjective = OneObjective;
Linking = TRUE;
}
else
{
ToObjective = OneObjective;
ShowLinkCosts(FromObjective, ToObjective);
// CampEnterCriticalSection();
if ( not UnLinkCampaignObjectives(FromObjective, ToObjective))
{
PathClass path;
i = LinkCampaignObjectives(&path, FromObjective, ToObjective);
if (i < 1)
MessageBox(NULL, "No valid path found", "Error", MB_OK bitor MB_ICONSTOP bitor MB_SETFOREGROUND);
if (MainMapData->ShowLinks and i > 0)
{
RECT r;
PAINTSTRUCT ps;
HDC DC;
MapData md = MainMapData;
GetClientRect(hMainWnd, &r);
InvalidateRect(hMainWnd, &r, FALSE);
DC = BeginPaint(hMainWnd, &ps);
_setcolor(DC, White);
ToObjective->GetLocation(&x, &y);
_moveto(DC, POSX(x) + (CellSize >> 1), POSY(y) + (CellSize >> 1));
FromObjective->GetLocation(&x, &y);
_lineto(DC, POSX(x) + (CellSize >> 1), POSY(y) + (CellSize >> 1));
EndPaint(hMainWnd, &ps);
}
else
{
MainMapData->ShowLinks = TRUE;
SetRefresh(MainMapData);
}
}
else if (MainMapData->ShowLinks)
SetRefresh(MainMapData);
ToObjective->RecalculateParent();
FromObjective->RecalculateParent();
ShowLinkCosts(FromObjective, ToObjective);
// CampLeaveCriticalSection();
Linking = FALSE;
Saved = FALSE;
}
}
break;
case 'L':
MainMapData->ShowLinks = not MainMapData->ShowLinks;
SetRefresh(MainMapData);
break;
case 'm':
DialogBox(hInst, MAKEINTRESOURCE(IDD_MISSTRIGDIALOG), hMainWnd, (DLGPROC)MissionTriggerProc);
break;
case 'M':
DialogBox(hInst, MAKEINTRESOURCE(IDD_MAPDIALOG), hMainWnd, (DLGPROC)MapDialogProc);
PostMessage(hMainWnd, WM_KEYUP, 16, 0);
break;
case 'n':
if (StateEdit)
{
OneObjective = FindNearestObjective(X, Y, NULL);
OneObjective->GetLocation(&x, &y);
if (x == X and y == Y)
{
RedrawCell(MainMapData, X, Y);
}
}
break;
case 'N':
Mode++;
if (Mode > 2)
Mode = 0;
SetRefresh(MainMapData);
break;
case 'o':
StartObjectiveEdit();
break;
case 'O':
MainMapData->ShowObjectives = not MainMapData->ShowObjectives;
RebuildParentsList();
SetRefresh(MainMapData);
break;
case 'p':
if ( not FindPath)
{
Movx = X;
Movy = Y;
FindPath = TRUE;
}
else
{
PathClass path;
CampEnterCriticalSection();
maxSearch = GROUND_PATH_MAX;
GetGridPath(&path, Movx, Movy, X, Y, gMoveType, gMoveWho, gMoveFlags);
maxSearch = MAX_SEARCH;
CampLeaveCriticalSection();
ShowPath(MainMapData, Movx, Movy, &path, White);
FindPath = FALSE;
}
break;
case 'P':
if ( not FindPath)
{
if (OneObjective)
{
FromObjective = OneObjective;
FindPath = TRUE;
}
}
else
{
PathClass path;
if (OneObjective)
{
CampEnterCriticalSection();
GetObjectivePath(&path, FromObjective, OneObjective, gMoveType, gMoveWho, gMoveFlags);
CampLeaveCriticalSection();
ShowObjectivePath(MainMapData, FromObjective, &path, Red);
FindPath = FALSE;
}
}
/* if (ShowPaths)
ShowPaths = 0;
else
ShowPaths = 1;
SetRefresh(MainMapData);
*/
break;
case 'Q':
ShowMissionLists();
break;
case 'r':
DialogBox(hInst, MAKEINTRESOURCE(IDD_TEAMDIALOG), hMainWnd, (DLGPROC)EditRelations);
break;
case 'R':
RoadsOn = not RoadsOn;
RailsOn = not RailsOn;
SetRefresh(MainMapData);
break;
case 's':
DialogBox(hInst, MAKEINTRESOURCE(IDD_SQUADRONDIALOG), hMainWnd, (DLGPROC)SelectSquadron);
break;
case 'S':
ShowSearch = not ShowSearch;
break;
case 't':
//SetTimeCompression (gameCompressionRatio / 2);
break;
case 'T':
//if (gameCompressionRatio < 1)
// SetTimeCompression (1);
//else
// SetTimeCompression *2; /*(gameCompressionRatio * 2);*/
break;
case 'u':
if (ptSelected == 2)
{
MoveUnits();
}
else
{
StartUnitEdit();
/*
if (ShowReal == 1)
OneUnit = FindUnitByXY(AllRealList,X,Y,0);
else if (ShowReal == 0)
OneUnit = FindUnitByXY(AllParentList,X,Y,0);
else if (ShowReal == 2)
OneUnit = FindUnitByXY(InactiveList,X,Y,0);
else
OneUnit = NULL; // Can't edit divisions
if (OneUnit)
GlobUnit = OneUnit;
else
GlobUnit = NULL;
if (GlobUnit)
DialogBox(hInst,MAKEINTRESOURCE(IDD_UNITDIALOG1),hMainWnd,(DLGPROC)EditUnit);
if (MainMapData->ShowWPs)
SetRefresh(MainMapData);
else
{
InvalidateRect(MainMapData->hMapWnd,NULL,FALSE);
PostMessage(MainMapData->hMapWnd,WM_PAINT,(WPARAM)hMainDC,0);
}*/
}
break;
case 'U':
MainMapData->ShowUnits = not MainMapData->ShowUnits;
SetRefresh(MainMapData);
break;
case 'v':
{
extern int GetTopPriorityObjectives(int team, _TCHAR * buffers[5]);
extern int GetTeamSituation(Team t);
_TCHAR* junk[5];
for (i = 0; i < 5; i++)
junk[i] = new _TCHAR[100];
GetTopPriorityObjectives(2, junk);
i = GetTeamSituation(2);
}
break;
case 'w':
if (WPUnit)
{
WayPoint w;
int gotone = 0;
w = WPUnit->GetFirstUnitWP();
while (w and not gotone)
{
w->GetWPLocation(&x, &y);
if (x == X and y == Y)
{
GlobWP = w;
DialogBox(hInst, MAKEINTRESOURCE(IDD_WPDIALOG), hMainWnd, (DLGPROC)EditWayPoint);
gotone = 1;
}
w = w->GetNextWP();
}
if ( not gotone)
{
w = WPUnit->GetFirstUnitWP();
if ( not w)
{
// WPUnit->AddCurrentWP (X,Y,0,0,0.0F,0,WP_NOTHING);
w = WPUnit->GetFirstUnitWP();
SetWPTimes(w, w->GetWPArrivalTime(), WPUnit->GetCruiseSpeed(), 0);
}
else
{
while (w->GetNextWP())
w = w->GetNextWP();
// GlobWP = WPUnit->AddWPAfter(w,X,Y,0,0,0.0F,0,WP_NOTHING);
w = WPUnit->GetFirstUnitWP();
SetWPTimes(w, w->GetWPArrivalTime(), WPUnit->GetCruiseSpeed());
DialogBox(hInst, MAKEINTRESOURCE(IDD_WPDIALOG), hMainWnd, (DLGPROC)EditWayPoint);
}
SetRefresh(MainMapData);
}
}
break;
case 'W':
if (WPUnit and not MainMapData->ShowWPs)
MainMapData->ShowWPs = TRUE;
else
MainMapData->ShowWPs = FALSE;
SetRefresh(MainMapData);
break;
case 'x':
case 'X':
MainMapData->CenX = CenX = X;
MainMapData->CenY = CenY = Y;
zoomOut(MainMapData);
break;
case 'z':
case 'Z':
MainMapData->CenX = CenX = X;
MainMapData->CenY = CenY = Y;
zoomIn(MainMapData);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
if (ptSelected == 2)
{
SetObjOwnersArea(Key - '1' + 1);
SetRefresh(MainMapData);
}
else
{
OneObjective = GetObjectiveByXY(X, Y);
if (OneObjective)
{
OneObjective->SetOwner(Key - '1' + 1);
}
SetRefresh(MainMapData);
}
break;
case 64:
NoInput = 0;
break;
case 139:
switch (Mode)
{
case 0:
case 1:
i = GetReliefType(GetCell(X, Y));
i++;
SetReliefType(GetCell(X, Y), (ReliefType)i);
break;
case 5:
case 6:
i = ((WeatherClass*)realWeather)->GetCloudLevel(X, Y);
i++;
((WeatherClass*)realWeather)->SetCloudLevel(X, Y, i);
break;
default:
break;
}
Saved = FALSE;
RedrawCell(MainMapData, X, Y);
break;
case 141:
switch (Mode)
{
case 0:
case 1:
i = GetReliefType(GetCell(X, Y));
i--;
SetReliefType(GetCell(X, Y), (ReliefType)i);
break;
case 5:
case 6:
i = ((WeatherClass*)realWeather)->GetCloudLevel(X, Y);
i--;
((WeatherClass*)realWeather)->SetCloudLevel(X, Y, i);
break;
default:
break;
}
Saved = FALSE;
RedrawCell(MainMapData, X, Y);
break;
default:
break;
}
}
/*************************************************************************\
*
* FUNCTION: CampMain(HANDLE, HANDLE, LPSTR, int)
*
* PURPOSE: calls initialization function, processes message loop
*
* COMMENTS:
*
\*************************************************************************/
void CampMain(HINSTANCE hInstance, int nCmdShow)
{
RECT rect;
WNDCLASS mainwc;
CenX = CenY = Map_Max_X / 2;
CellSize = 4;
MaxXSize = MAX_XPIX / CellSize;
MaxYSize = MAX_YPIX / CellSize;
srand((unsigned) time(NULL));
InitDebug(DEBUGGER_TEXT_MODE);
if (campCritical == NULL)
{
campCritical = F4CreateCriticalSection("campCritical");
}
hCurWait = LoadCursor(NULL, IDC_WAIT);
hCurPoint = LoadCursor(NULL, IDC_ARROW);
// Set up the main window
mainwc.style = CS_HREDRAW bitor CS_VREDRAW;
mainwc.lpfnWndProc = (WNDPROC)CampaignWndProc; // The client window procedure.
mainwc.cbClsExtra = 0; // No room reserved for extra data.
mainwc.cbWndExtra = sizeof(DWORD);
mainwc.hInstance = hInstance;
mainwc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
mainwc.hCursor = NULL;
mainwc.hbrBackground = Brushes[Blue];
mainwc.lpszMenuName = MAKEINTRESOURCE(IDR_CAMPAIGN_MENU);
mainwc.lpszClassName = "CampTool";
RegisterClass(&mainwc);
rect.top = rect.left = 0;
rect.right = 320;
rect.bottom = 256;
// Note: This should work, but currently doesnt. MSVC++ bug?
// AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW bitor WS_HSCROLL bitor WS_VSCROLL, TRUE);
AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, TRUE);
rect.right += GetSystemMetrics(SM_CXVSCROLL);
rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
hMainWnd = CreateWindow("CampTool",
"Campaign Tool",
WS_OVERLAPPEDWINDOW bitor WS_HSCROLL bitor WS_VSCROLL, // bitor WS_MAXIMIZE,
CW_USEDEFAULT, // WS_CLIPCHILDREN |
CW_USEDEFAULT,
rect.right - rect.left, /* init. x size */
rect.bottom - rect.top, /* init. y size */
NULL,
NULL,
hInstance,
NULL);
// set up data associated with this window
SetWindowPos(hMainWnd, HWND_TOP, 600, 400, 650, 600, SWP_NOSIZE bitor SWP_NOZORDER);
ShowWindow(hMainWnd, SW_SHOW);
UpdateWindow(hMainWnd);
RefreshCampMap();
}
void CampaignWindow(HINSTANCE hInstance, int nCmdShow)
{
WNDCLASS toolwc;
// Set up the time/location window
toolwc.style = CS_HREDRAW bitor CS_VREDRAW;
toolwc.lpfnWndProc = (WNDPROC)ToolWndProc; // The client window procedure.
toolwc.cbClsExtra = 0; // No room reserved for extra data.
toolwc.cbWndExtra = sizeof(DWORD);
toolwc.hInstance = hInstance;
toolwc.hIcon = NULL; // LoadIcon (NULL, IDI_APPLICATION);
toolwc.hCursor = NULL;
toolwc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
toolwc.lpszMenuName = "";
toolwc.lpszClassName = "Toolbar";
RegisterClass(&toolwc);
hToolWnd = CreateWindow("Toolbar",
"Toolbar",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
300,
100,
NULL,
NULL,
hInstance,
NULL);
// set up data associated with this window
SetWindowPos(hToolWnd, HWND_TOP, 10, 10, 10, 10, SWP_NOSIZE bitor SWP_NOZORDER);
ShowWindow(hToolWnd, SW_SHOW);
UpdateWindow(hToolWnd);
}
void ShowCampaign(void)
{
if (hMainWnd)
{
ShowWindow(hMainWnd, SW_SHOW);
UpdateWindow(hMainWnd);
}
if (hToolWnd)
{
ShowWindow(hToolWnd, SW_SHOW);
UpdateWindow(hToolWnd);
}
}
#endif CAMPTOOL
| 28.904031 | 240 | 0.475513 | Terebinth |
b358a08977c1c98f7833bb2dc227c8fa42e29c3c | 46,179 | cc | C++ | net/dns/dns_transaction.cc | zipated/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | net/dns/dns_transaction.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | net/dns/dns_transaction.cc | cangulcan/src | 2b8388091c71e442910a21ada3d97ae8bc1845d3 | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/dns/dns_transaction.h"
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/base64url.h"
#include "base/big_endian.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/containers/circular_deque.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/rand_util.h"
#include "base/single_thread_task_runner.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/threading/thread_checker.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/timer/timer.h"
#include "base/values.h"
#include "build/build_config.h"
#include "net/base/completion_callback.h"
#include "net/base/elements_upload_data_stream.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/load_flags.h"
#include "net/base/net_errors.h"
#include "net/base/upload_bytes_element_reader.h"
#include "net/dns/dns_protocol.h"
#include "net/dns/dns_query.h"
#include "net/dns/dns_response.h"
#include "net/dns/dns_session.h"
#include "net/dns/dns_util.h"
#include "net/log/net_log.h"
#include "net/log/net_log_capture_mode.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_with_source.h"
#include "net/socket/datagram_client_socket.h"
#include "net/socket/stream_socket.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "net/url_request/url_fetcher_response_writer.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_builder.h"
namespace net {
namespace {
constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation =
net::DefineNetworkTrafficAnnotation("dns_transaction", R"(
semantics {
sender: "DNS Transaction"
description:
"DNS Transaction implements a stub DNS resolver as defined in RFC "
"1034."
trigger:
"Any network request that may require DNS resolution, including "
"navigations, connecting to a proxy server, detecting proxy "
"settings, getting proxy config, certificate checking, and more."
data:
"Domain name that needs resolution."
destination: OTHER
destination_other:
"The connection is made to a DNS server based on user's network "
"settings."
}
policy {
cookies_allowed: NO
setting:
"This feature cannot be disabled. Without DNS Transactions Chrome "
"cannot resolve host names."
policy_exception_justification:
"Essential for Chrome's navigation."
})");
const char kDnsOverHttpResponseContentType[] = "application/dns-udpwireformat";
// Count labels in the fully-qualified name in DNS format.
int CountLabels(const std::string& name) {
size_t count = 0;
for (size_t i = 0; i < name.size() && name[i]; i += name[i] + 1)
++count;
return count;
}
bool IsIPLiteral(const std::string& hostname) {
IPAddress ip;
return ip.AssignFromIPLiteral(hostname);
}
std::unique_ptr<base::Value> NetLogStartCallback(
const std::string* hostname,
uint16_t qtype,
NetLogCaptureMode /* capture_mode */) {
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetString("hostname", *hostname);
dict->SetInteger("query_type", qtype);
return std::move(dict);
}
// Values are used in UMA histograms. Do not change existing values.
enum MalformedResponseResult {
MALFORMED_OK = 0,
MALFORMED_MALFORMED = 1,
MALFORMED_FAILED = 2,
MALFORMED_MAX
};
void RecordMalformedResponseHistogram(int net_error) {
MalformedResponseResult error_type;
if (net_error == OK)
error_type = MALFORMED_OK;
else if (net_error == ERR_DNS_MALFORMED_RESPONSE)
error_type = MALFORMED_MALFORMED;
else
error_type = MALFORMED_FAILED;
UMA_HISTOGRAM_ENUMERATION("Net.DNS.ResultAfterMalformedResponse", error_type,
MALFORMED_MAX);
}
// ----------------------------------------------------------------------------
// A single asynchronous DNS exchange, which consists of sending out a
// DNS query, waiting for a response, and returning the response that it
// matches. Logging is done in the socket and in the outer DnsTransaction.
class DnsAttempt {
public:
explicit DnsAttempt(unsigned server_index)
: result_(ERR_FAILED), server_index_(server_index) {}
virtual ~DnsAttempt() = default;
// Starts the attempt. Returns ERR_IO_PENDING if cannot complete synchronously
// and calls |callback| upon completion.
virtual int Start(const CompletionCallback& callback) = 0;
// Returns the query of this attempt.
virtual const DnsQuery* GetQuery() const = 0;
// Returns the response or NULL if has not received a matching response from
// the server.
virtual const DnsResponse* GetResponse() const = 0;
// Returns the net log bound to the source of the socket.
virtual const NetLogWithSource& GetSocketNetLog() const = 0;
// Returns the index of the destination server within DnsConfig::nameservers.
unsigned server_index() const { return server_index_; }
// Returns a Value representing the received response, along with a reference
// to the NetLog source source of the UDP socket used. The request must have
// completed before this is called.
std::unique_ptr<base::Value> NetLogResponseCallback(
NetLogCaptureMode capture_mode) const {
DCHECK(GetResponse()->IsValid());
std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
dict->SetInteger("rcode", GetResponse()->rcode());
dict->SetInteger("answer_count", GetResponse()->answer_count());
GetSocketNetLog().source().AddToEventParameters(dict.get());
return std::move(dict);
}
void set_result(int result) {
result_ = result;
}
// True if current attempt is pending (waiting for server response).
bool is_pending() const {
return result_ == ERR_IO_PENDING;
}
// True if attempt is completed (received server response).
bool is_completed() const {
return (result_ == OK) || (result_ == ERR_NAME_NOT_RESOLVED) ||
(result_ == ERR_DNS_SERVER_REQUIRES_TCP);
}
private:
// Result of last operation.
int result_;
const unsigned server_index_;
};
class DnsUDPAttempt : public DnsAttempt {
public:
DnsUDPAttempt(unsigned server_index,
std::unique_ptr<DnsSession::SocketLease> socket_lease,
std::unique_ptr<DnsQuery> query)
: DnsAttempt(server_index),
next_state_(STATE_NONE),
received_malformed_response_(false),
socket_lease_(std::move(socket_lease)),
query_(std::move(query)) {}
// DnsAttempt:
int Start(const CompletionCallback& callback) override {
DCHECK_EQ(STATE_NONE, next_state_);
callback_ = callback;
start_time_ = base::TimeTicks::Now();
next_state_ = STATE_SEND_QUERY;
return DoLoop(OK);
}
const DnsQuery* GetQuery() const override { return query_.get(); }
const DnsResponse* GetResponse() const override {
const DnsResponse* resp = response_.get();
return (resp != NULL && resp->IsValid()) ? resp : NULL;
}
const NetLogWithSource& GetSocketNetLog() const override {
return socket_lease_->socket()->NetLog();
}
private:
enum State {
STATE_SEND_QUERY,
STATE_SEND_QUERY_COMPLETE,
STATE_READ_RESPONSE,
STATE_READ_RESPONSE_COMPLETE,
STATE_NONE,
};
DatagramClientSocket* socket() {
return socket_lease_->socket();
}
int DoLoop(int result) {
CHECK_NE(STATE_NONE, next_state_);
int rv = result;
do {
State state = next_state_;
next_state_ = STATE_NONE;
switch (state) {
case STATE_SEND_QUERY:
rv = DoSendQuery();
break;
case STATE_SEND_QUERY_COMPLETE:
rv = DoSendQueryComplete(rv);
break;
case STATE_READ_RESPONSE:
rv = DoReadResponse();
break;
case STATE_READ_RESPONSE_COMPLETE:
rv = DoReadResponseComplete(rv);
break;
default:
NOTREACHED();
break;
}
} while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
set_result(rv);
if (received_malformed_response_) {
// If we received a malformed response, and are now waiting for another
// one, indicate to the transaction that the server might be misbehaving.
if (rv == ERR_IO_PENDING)
return ERR_DNS_MALFORMED_RESPONSE;
// This is a new response after the original malformed one.
RecordMalformedResponseHistogram(rv);
}
if (rv == OK) {
DCHECK_EQ(STATE_NONE, next_state_);
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.UDPAttemptSuccess",
base::TimeTicks::Now() - start_time_);
} else if (rv != ERR_IO_PENDING) {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.UDPAttemptFail",
base::TimeTicks::Now() - start_time_);
}
return rv;
}
int DoSendQuery() {
next_state_ = STATE_SEND_QUERY_COMPLETE;
return socket()->Write(
query_->io_buffer(), query_->io_buffer()->size(),
base::BindOnce(&DnsUDPAttempt::OnIOComplete, base::Unretained(this)),
kTrafficAnnotation);
}
int DoSendQueryComplete(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
// Writing to UDP should not result in a partial datagram.
if (rv != query_->io_buffer()->size())
return ERR_MSG_TOO_BIG;
next_state_ = STATE_READ_RESPONSE;
return OK;
}
int DoReadResponse() {
next_state_ = STATE_READ_RESPONSE_COMPLETE;
response_ = std::make_unique<DnsResponse>();
return socket()->Read(
response_->io_buffer(), response_->io_buffer_size(),
base::BindOnce(&DnsUDPAttempt::OnIOComplete, base::Unretained(this)));
}
int DoReadResponseComplete(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
DCHECK(rv);
if (!response_->InitParse(rv, *query_)) {
// Other implementations simply ignore mismatched responses. Since each
// DnsUDPAttempt binds to a different port, we might find that responses
// to previously timed out queries lead to failures in the future.
// Our solution is to make another attempt, in case the query truly
// failed, but keep this attempt alive, in case it was a false alarm.
received_malformed_response_ = true;
RecordMalformedResponseHistogram(ERR_DNS_MALFORMED_RESPONSE);
next_state_ = STATE_READ_RESPONSE;
return OK;
}
if (response_->flags() & dns_protocol::kFlagTC)
return ERR_DNS_SERVER_REQUIRES_TCP;
if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
return ERR_NAME_NOT_RESOLVED;
if (response_->rcode() != dns_protocol::kRcodeNOERROR)
return ERR_DNS_SERVER_FAILED;
return OK;
}
void OnIOComplete(int rv) {
rv = DoLoop(rv);
if (rv != ERR_IO_PENDING)
callback_.Run(rv);
}
State next_state_;
bool received_malformed_response_;
base::TimeTicks start_time_;
std::unique_ptr<DnsSession::SocketLease> socket_lease_;
std::unique_ptr<DnsQuery> query_;
std::unique_ptr<DnsResponse> response_;
CompletionCallback callback_;
DISALLOW_COPY_AND_ASSIGN(DnsUDPAttempt);
};
class DnsHTTPAttempt : public DnsAttempt, public URLRequest::Delegate {
public:
DnsHTTPAttempt(unsigned server_index,
std::unique_ptr<DnsQuery> query,
const GURL& server,
bool use_post,
URLRequestContext* url_request_context,
RequestPriority request_priority_)
: DnsAttempt(server_index),
query_(std::move(query)),
weak_factory_(this) {
GURL url(server);
if (!use_post) {
std::string encoded_query;
base::Base64UrlEncode(base::StringPiece(query_->io_buffer()->data(),
query_->io_buffer()->size()),
base::Base64UrlEncodePolicy::INCLUDE_PADDING,
&encoded_query);
std::string query_str("content-type=application/dns-udpwireformat&body=" +
encoded_query);
GURL::Replacements replacements;
replacements.SetQuery(query_str.c_str(),
url::Component(0, query_str.length()));
url = server.ReplaceComponents(replacements);
}
HttpRequestHeaders extra_request_headers;
extra_request_headers.SetHeader("Accept", kDnsOverHttpResponseContentType);
request_ = url_request_context->CreateRequest(
url, request_priority_, this,
net::DefineNetworkTrafficAnnotation("dns_over_https", R"(
semantics {
sender: "DNS over HTTPS"
description: "Domain name resolution over HTTPS"
trigger: "User enters a navigates to a domain or Chrome otherwise "
"makes a connection to a domain whose IP address isn't cached"
data: "The domain name that is being requested"
destination: OTHER
destination_other: "The user configured DNS over HTTPS server, which"
"may be dns.google.com"
}
policy {
cookies_allowed: NO
setting:
"You can configure this feature via that 'dns_over_https_servers' and"
"'dns_over_https.method' prefs. Empty lists imply this feature is"
"disabled"
policy_exception_justification: "Experimental feature that"
"is disabled by default"
}
)"));
net_log_ = request_->net_log();
if (use_post) {
request_->set_method("POST");
std::unique_ptr<UploadElementReader> reader =
std::make_unique<UploadBytesElementReader>(
query_->io_buffer()->data(), query_->io_buffer()->size());
request_->set_upload(
ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
extra_request_headers.SetHeader(HttpRequestHeaders::kContentType,
kDnsOverHttpResponseContentType);
}
request_->SetExtraRequestHeaders(extra_request_headers);
request_->SetLoadFlags(request_->load_flags() | LOAD_DISABLE_CACHE |
LOAD_BYPASS_PROXY | LOAD_DO_NOT_SEND_COOKIES |
LOAD_DO_NOT_SAVE_COOKIES |
LOAD_DO_NOT_SEND_AUTH_DATA);
}
// DnsAttempt overrides.
int Start(const CompletionCallback& callback) override {
if (DNSDomainToString(query_->qname()).compare(request_->url().host()) ==
0) {
// Fast failing looking up a server with itself.
return ERR_DNS_HTTP_FAILED;
}
callback_ = callback;
request_->Start();
return ERR_IO_PENDING;
}
void Cancel() { request_.reset(); }
const DnsQuery* GetQuery() const override { return query_.get(); }
const DnsResponse* GetResponse() const override {
const DnsResponse* resp = response_.get();
return (resp != NULL && resp->IsValid()) ? resp : NULL;
}
const NetLogWithSource& GetSocketNetLog() const override { return net_log_; }
// URLRequest::Delegate overrides
void OnResponseStarted(net::URLRequest* request, int net_error) override {
DCHECK_NE(net::ERR_IO_PENDING, net_error);
std::string content_type;
if (net_error != OK) {
ResponseCompleted(net_error);
return;
}
if (request_->GetResponseCode() != 200 ||
!request->response_headers()->GetMimeType(&content_type) ||
0 != content_type.compare(kDnsOverHttpResponseContentType)) {
ResponseCompleted(ERR_DNS_MALFORMED_RESPONSE);
return;
}
buffer_ = new GrowableIOBuffer();
if (request->response_headers()->HasHeader(
HttpRequestHeaders::kContentLength)) {
buffer_->SetCapacity(request_->response_headers()->GetContentLength() +
1);
} else {
buffer_->SetCapacity(66560); // 64kb.
}
DCHECK(buffer_->data());
DCHECK_GT(buffer_->capacity(), 0);
int bytes_read =
request_->Read(buffer_.get(), buffer_->RemainingCapacity());
// If IO is pending, wait for the URLRequest to call OnReadCompleted.
if (bytes_read == net::ERR_IO_PENDING)
return;
OnReadCompleted(request_.get(), bytes_read);
}
void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
// bytes_read can be an error.
if (bytes_read < 0) {
ResponseCompleted(bytes_read);
return;
}
DCHECK_GE(bytes_read, 0);
if (bytes_read > 0) {
buffer_->set_offset(buffer_->offset() + bytes_read);
if (buffer_->RemainingCapacity() == 0) {
buffer_->SetCapacity(buffer_->capacity() + 16384); // Grow by 16kb.
}
DCHECK(buffer_->data());
DCHECK_GT(buffer_->capacity(), 0);
int bytes_read =
request_->Read(buffer_.get(), buffer_->RemainingCapacity());
// If IO is pending, wait for the URLRequest to call OnReadCompleted.
if (bytes_read == net::ERR_IO_PENDING)
return;
if (bytes_read <= 0) {
OnReadCompleted(request_.get(), bytes_read);
} else {
// Else, trigger OnReadCompleted asynchronously to avoid starving the IO
// thread in case the URLRequest can provide data synchronously.
base::SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::BindOnce(&DnsHTTPAttempt::OnReadCompleted,
weak_factory_.GetWeakPtr(),
request_.get(), bytes_read));
}
} else {
// URLRequest reported an EOF. Call ResponseCompleted.
DCHECK_EQ(0, bytes_read);
ResponseCompleted(net::OK);
}
}
private:
void ResponseCompleted(int net_error) {
request_.reset();
callback_.Run(CompleteResponse(net_error));
}
int CompleteResponse(int net_error) {
DCHECK_NE(net::ERR_IO_PENDING, net_error);
if (net_error != OK) {
return net_error;
}
if (!buffer_.get() || 0 == buffer_->capacity())
return ERR_DNS_MALFORMED_RESPONSE;
size_t size = buffer_->offset();
buffer_->set_offset(0);
if (size == 0u)
return ERR_DNS_MALFORMED_RESPONSE;
response_ = std::make_unique<DnsResponse>(buffer_.get(), size + 1);
if (!response_->InitParse(size, *query_))
return ERR_DNS_MALFORMED_RESPONSE;
if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
return ERR_NAME_NOT_RESOLVED;
if (response_->rcode() != dns_protocol::kRcodeNOERROR)
return ERR_DNS_SERVER_FAILED;
return OK;
}
scoped_refptr<GrowableIOBuffer> buffer_;
std::unique_ptr<DnsQuery> query_;
CompletionCallback callback_;
std::unique_ptr<DnsResponse> response_;
std::unique_ptr<URLRequest> request_;
NetLogWithSource net_log_;
base::WeakPtrFactory<DnsHTTPAttempt> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(DnsHTTPAttempt);
};
class DnsTCPAttempt : public DnsAttempt {
public:
DnsTCPAttempt(unsigned server_index,
std::unique_ptr<StreamSocket> socket,
std::unique_ptr<DnsQuery> query)
: DnsAttempt(server_index),
next_state_(STATE_NONE),
socket_(std::move(socket)),
query_(std::move(query)),
length_buffer_(new IOBufferWithSize(sizeof(uint16_t))),
response_length_(0) {}
// DnsAttempt:
int Start(const CompletionCallback& callback) override {
DCHECK_EQ(STATE_NONE, next_state_);
callback_ = callback;
start_time_ = base::TimeTicks::Now();
next_state_ = STATE_CONNECT_COMPLETE;
int rv = socket_->Connect(
base::BindOnce(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
if (rv == ERR_IO_PENDING) {
set_result(rv);
return rv;
}
return DoLoop(rv);
}
const DnsQuery* GetQuery() const override { return query_.get(); }
const DnsResponse* GetResponse() const override {
const DnsResponse* resp = response_.get();
return (resp != NULL && resp->IsValid()) ? resp : NULL;
}
const NetLogWithSource& GetSocketNetLog() const override {
return socket_->NetLog();
}
private:
enum State {
STATE_CONNECT_COMPLETE,
STATE_SEND_LENGTH,
STATE_SEND_QUERY,
STATE_READ_LENGTH,
STATE_READ_LENGTH_COMPLETE,
STATE_READ_RESPONSE,
STATE_READ_RESPONSE_COMPLETE,
STATE_NONE,
};
int DoLoop(int result) {
CHECK_NE(STATE_NONE, next_state_);
int rv = result;
do {
State state = next_state_;
next_state_ = STATE_NONE;
switch (state) {
case STATE_CONNECT_COMPLETE:
rv = DoConnectComplete(rv);
break;
case STATE_SEND_LENGTH:
rv = DoSendLength(rv);
break;
case STATE_SEND_QUERY:
rv = DoSendQuery(rv);
break;
case STATE_READ_LENGTH:
rv = DoReadLength(rv);
break;
case STATE_READ_LENGTH_COMPLETE:
rv = DoReadLengthComplete(rv);
break;
case STATE_READ_RESPONSE:
rv = DoReadResponse(rv);
break;
case STATE_READ_RESPONSE_COMPLETE:
rv = DoReadResponseComplete(rv);
break;
default:
NOTREACHED();
break;
}
} while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
set_result(rv);
if (rv == OK) {
DCHECK_EQ(STATE_NONE, next_state_);
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TCPAttemptSuccess",
base::TimeTicks::Now() - start_time_);
} else if (rv != ERR_IO_PENDING) {
UMA_HISTOGRAM_LONG_TIMES_100("AsyncDNS.TCPAttemptFail",
base::TimeTicks::Now() - start_time_);
}
return rv;
}
int DoConnectComplete(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
uint16_t query_size = static_cast<uint16_t>(query_->io_buffer()->size());
if (static_cast<int>(query_size) != query_->io_buffer()->size())
return ERR_FAILED;
base::WriteBigEndian<uint16_t>(length_buffer_->data(), query_size);
buffer_ =
new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
next_state_ = STATE_SEND_LENGTH;
return OK;
}
int DoSendLength(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
buffer_->DidConsume(rv);
if (buffer_->BytesRemaining() > 0) {
next_state_ = STATE_SEND_LENGTH;
return socket_->Write(
buffer_.get(), buffer_->BytesRemaining(),
base::BindOnce(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)),
kTrafficAnnotation);
}
buffer_ =
new DrainableIOBuffer(query_->io_buffer(), query_->io_buffer()->size());
next_state_ = STATE_SEND_QUERY;
return OK;
}
int DoSendQuery(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
buffer_->DidConsume(rv);
if (buffer_->BytesRemaining() > 0) {
next_state_ = STATE_SEND_QUERY;
return socket_->Write(
buffer_.get(), buffer_->BytesRemaining(),
base::BindOnce(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)),
kTrafficAnnotation);
}
buffer_ =
new DrainableIOBuffer(length_buffer_.get(), length_buffer_->size());
next_state_ = STATE_READ_LENGTH;
return OK;
}
int DoReadLength(int rv) {
DCHECK_EQ(OK, rv);
next_state_ = STATE_READ_LENGTH_COMPLETE;
return ReadIntoBuffer();
}
int DoReadLengthComplete(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
if (rv == 0)
return ERR_CONNECTION_CLOSED;
buffer_->DidConsume(rv);
if (buffer_->BytesRemaining() > 0) {
next_state_ = STATE_READ_LENGTH;
return OK;
}
base::ReadBigEndian<uint16_t>(length_buffer_->data(), &response_length_);
// Check if advertised response is too short. (Optimization only.)
if (response_length_ < query_->io_buffer()->size())
return ERR_DNS_MALFORMED_RESPONSE;
// Allocate more space so that DnsResponse::InitParse sanity check passes.
response_.reset(new DnsResponse(response_length_ + 1));
buffer_ = new DrainableIOBuffer(response_->io_buffer(), response_length_);
next_state_ = STATE_READ_RESPONSE;
return OK;
}
int DoReadResponse(int rv) {
DCHECK_EQ(OK, rv);
next_state_ = STATE_READ_RESPONSE_COMPLETE;
return ReadIntoBuffer();
}
int DoReadResponseComplete(int rv) {
DCHECK_NE(ERR_IO_PENDING, rv);
if (rv < 0)
return rv;
if (rv == 0)
return ERR_CONNECTION_CLOSED;
buffer_->DidConsume(rv);
if (buffer_->BytesRemaining() > 0) {
next_state_ = STATE_READ_RESPONSE;
return OK;
}
DCHECK_GT(buffer_->BytesConsumed(), 0);
if (!response_->InitParse(buffer_->BytesConsumed(), *query_))
return ERR_DNS_MALFORMED_RESPONSE;
if (response_->flags() & dns_protocol::kFlagTC)
return ERR_UNEXPECTED;
// TODO(szym): Frankly, none of these are expected.
if (response_->rcode() == dns_protocol::kRcodeNXDOMAIN)
return ERR_NAME_NOT_RESOLVED;
if (response_->rcode() != dns_protocol::kRcodeNOERROR)
return ERR_DNS_SERVER_FAILED;
return OK;
}
void OnIOComplete(int rv) {
rv = DoLoop(rv);
if (rv != ERR_IO_PENDING)
callback_.Run(rv);
}
int ReadIntoBuffer() {
return socket_->Read(
buffer_.get(), buffer_->BytesRemaining(),
base::BindOnce(&DnsTCPAttempt::OnIOComplete, base::Unretained(this)));
}
State next_state_;
base::TimeTicks start_time_;
std::unique_ptr<StreamSocket> socket_;
std::unique_ptr<DnsQuery> query_;
scoped_refptr<IOBufferWithSize> length_buffer_;
scoped_refptr<DrainableIOBuffer> buffer_;
uint16_t response_length_;
std::unique_ptr<DnsResponse> response_;
CompletionCallback callback_;
DISALLOW_COPY_AND_ASSIGN(DnsTCPAttempt);
};
// ----------------------------------------------------------------------------
// Implements DnsTransaction. Configuration is supplied by DnsSession.
// The suffix list is built according to the DnsConfig from the session.
// The timeout for each DnsUDPAttempt is given by DnsSession::NextTimeout.
// The first server to attempt on each query is given by
// DnsSession::NextFirstServerIndex, and the order is round-robin afterwards.
// Each server is attempted DnsConfig::attempts times.
class DnsTransactionImpl : public DnsTransaction,
public base::SupportsWeakPtr<DnsTransactionImpl> {
public:
DnsTransactionImpl(DnsSession* session,
const std::string& hostname,
uint16_t qtype,
DnsTransactionFactory::CallbackType& callback,
const NetLogWithSource& net_log,
const OptRecordRdata* opt_rdata)
: session_(session),
hostname_(hostname),
qtype_(qtype),
opt_rdata_(opt_rdata),
callback_(std::move(callback)),
net_log_(net_log),
qnames_initial_size_(0),
attempts_count_(0),
doh_attempts_(0),
had_tcp_attempt_(false),
doh_attempt_(false),
first_server_index_(0),
request_priority_(DEFAULT_PRIORITY) {
DCHECK(session_.get());
DCHECK(!hostname_.empty());
DCHECK(!callback_.is_null());
DCHECK(!IsIPLiteral(hostname_));
}
~DnsTransactionImpl() override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
if (!callback_.is_null()) {
net_log_.EndEventWithNetErrorCode(NetLogEventType::DNS_TRANSACTION,
ERR_ABORTED);
} // otherwise logged in DoCallback or Start
}
const std::string& GetHostname() const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return hostname_;
}
uint16_t GetType() const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
return qtype_;
}
void Start() override {
DCHECK(!callback_.is_null());
DCHECK(attempts_.empty());
net_log_.BeginEvent(NetLogEventType::DNS_TRANSACTION,
base::Bind(&NetLogStartCallback, &hostname_, qtype_));
AttemptResult result(PrepareSearch(), NULL);
if (result.rv == OK) {
qnames_initial_size_ = qnames_.size();
if (qtype_ == dns_protocol::kTypeA)
UMA_HISTOGRAM_COUNTS_1M("AsyncDNS.SuffixSearchStart", qnames_.size());
result = ProcessAttemptResult(StartQuery());
}
// Must always return result asynchronously, to avoid reentrancy.
if (result.rv != ERR_IO_PENDING) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::Bind(&DnsTransactionImpl::DoCallback, AsWeakPtr(), result));
}
}
void SetRequestContext(URLRequestContext* context) override {
url_request_context_ = context;
}
void SetRequestPriority(RequestPriority priority) override {
request_priority_ = priority;
}
private:
// Wrapper for the result of a DnsUDPAttempt.
struct AttemptResult {
AttemptResult(int rv, const DnsAttempt* attempt)
: rv(rv), attempt(attempt) {}
int rv;
const DnsAttempt* attempt;
};
// Prepares |qnames_| according to the DnsConfig.
int PrepareSearch() {
const DnsConfig& config = session_->config();
std::string labeled_hostname;
if (!DNSDomainFromDot(hostname_, &labeled_hostname))
return ERR_INVALID_ARGUMENT;
if (hostname_.back() == '.') {
// It's a fully-qualified name, no suffix search.
qnames_.push_back(labeled_hostname);
return OK;
}
int ndots = CountLabels(labeled_hostname) - 1;
if (ndots > 0 && !config.append_to_multi_label_name) {
qnames_.push_back(labeled_hostname);
return OK;
}
// Set true when |labeled_hostname| is put on the list.
bool had_hostname = false;
if (ndots >= config.ndots) {
qnames_.push_back(labeled_hostname);
had_hostname = true;
}
std::string qname;
for (size_t i = 0; i < config.search.size(); ++i) {
// Ignore invalid (too long) combinations.
if (!DNSDomainFromDot(hostname_ + "." + config.search[i], &qname))
continue;
if (qname.size() == labeled_hostname.size()) {
if (had_hostname)
continue;
had_hostname = true;
}
qnames_.push_back(qname);
}
if (ndots > 0 && !had_hostname)
qnames_.push_back(labeled_hostname);
return qnames_.empty() ? ERR_DNS_SEARCH_EMPTY : OK;
}
void DoCallback(AttemptResult result) {
DCHECK_NE(ERR_IO_PENDING, result.rv);
// TODO(mgersh): consider changing back to a DCHECK once
// https://crbug.com/779589 is fixed.
if (callback_.is_null())
return;
const DnsResponse* response =
result.attempt ? result.attempt->GetResponse() : NULL;
CHECK(result.rv != OK || response != NULL);
timer_.Stop();
RecordLostPacketsIfAny();
if (result.rv == OK)
UMA_HISTOGRAM_COUNTS_1M("AsyncDNS.AttemptCountSuccess", attempts_count_);
else
UMA_HISTOGRAM_COUNTS_1M("AsyncDNS.AttemptCountFail", attempts_count_);
if (response && qtype_ == dns_protocol::kTypeA) {
UMA_HISTOGRAM_COUNTS_1M("AsyncDNS.SuffixSearchRemain", qnames_.size());
UMA_HISTOGRAM_COUNTS_1M("AsyncDNS.SuffixSearchDone",
qnames_initial_size_ - qnames_.size());
}
net_log_.EndEventWithNetErrorCode(NetLogEventType::DNS_TRANSACTION,
result.rv);
std::move(callback_).Run(this, result.rv, response);
}
bool IsHostInDnsOverHttpsServerList(const std::string& host) const {
for (const auto& server : session_->config().dns_over_https_servers) {
if (host == server.server.host_piece())
return true;
}
return false;
}
AttemptResult MakeAttempt() {
// Make an HTTP attempt unless we have already made more attempts
// than we have configured servers. Otherwise make a UDP attempt
// as long as we have configured nameservers.
DnsConfig config = session_->config();
if (doh_attempts_ < config.dns_over_https_servers.size())
return MakeHTTPAttempt(config.dns_over_https_servers);
DCHECK_GT(config.nameservers.size(), 0u);
return MakeUDPAttempt();
}
// Makes another attempt at the current name, |qnames_.front()|, using the
// next nameserver.
AttemptResult MakeUDPAttempt() {
doh_attempt_ = false;
unsigned attempt_number = attempts_.size();
uint16_t id = session_->NextQueryId();
std::unique_ptr<DnsQuery> query;
if (attempts_.empty()) {
query.reset(new DnsQuery(id, qnames_.front(), qtype_, opt_rdata_));
} else {
query = attempts_[0]->GetQuery()->CloneWithNewId(id);
}
const DnsConfig& config = session_->config();
unsigned non_doh_server_index =
(first_server_index_ + attempt_number - doh_attempts_) %
config.nameservers.size();
// Skip over known failed servers.
non_doh_server_index = session_->NextGoodServerIndex(non_doh_server_index);
std::unique_ptr<DnsSession::SocketLease> lease =
session_->AllocateSocket(non_doh_server_index, net_log_.source());
bool got_socket = !!lease.get();
DnsUDPAttempt* attempt = new DnsUDPAttempt(
non_doh_server_index, std::move(lease), std::move(query));
attempts_.push_back(base::WrapUnique(attempt));
++attempts_count_;
if (!got_socket)
return AttemptResult(ERR_CONNECTION_REFUSED, NULL);
net_log_.AddEvent(
NetLogEventType::DNS_TRANSACTION_ATTEMPT,
attempt->GetSocketNetLog().source().ToEventParametersCallback());
int rv = attempt->Start(base::Bind(
&DnsTransactionImpl::OnUdpAttemptComplete, base::Unretained(this),
attempt_number, base::TimeTicks::Now()));
if (rv == ERR_IO_PENDING) {
base::TimeDelta timeout =
session_->NextTimeout(non_doh_server_index, attempt_number);
timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
}
return AttemptResult(rv, attempt);
}
AttemptResult MakeHTTPAttempt(
const std::vector<DnsConfig::DnsOverHttpsServerConfig>& servers) {
doh_attempt_ = true;
unsigned attempt_number = attempts_.size();
uint16_t id = session_->NextQueryId();
std::unique_ptr<DnsQuery> query;
if (attempts_.empty()) {
query.reset(new DnsQuery(id, qnames_.front(), qtype_, opt_rdata_));
} else {
query = attempts_[0]->GetQuery()->CloneWithNewId(id);
}
// doh_attempts_ counts the number of attempts made via HTTPS. To
// get a server index cap that by the number of DoH servers we
// have configured and then offset it by the number of non-doh
// servers we have configured since they come first in the server
// stats list.
unsigned server_index = session_->NextGoodDnsOverHttpsServerIndex(
(doh_attempts_ % session_->config().dns_over_https_servers.size()) +
session_->config().nameservers.size());
attempts_.push_back(std::make_unique<DnsHTTPAttempt>(
server_index, std::move(query),
servers[server_index - session_->config().nameservers.size()].server,
servers[server_index - session_->config().nameservers.size()].use_post,
url_request_context_, request_priority_));
++doh_attempts_;
++attempts_count_;
// Check that we're not looking one of the DNS over HTTPS servers.
if (IsHostInDnsOverHttpsServerList(DNSDomainToString(qnames_.front()))) {
static_cast<DnsHTTPAttempt*>(attempts_.back().get())->Cancel();
return AttemptResult(ERR_CONNECTION_REFUSED, attempts_.back().get());
}
int rv = attempts_.back()->Start(
base::Bind(&DnsTransactionImpl::OnAttemptComplete,
base::Unretained(this), attempt_number));
return AttemptResult(rv, attempts_.back().get());
}
AttemptResult MakeTCPAttempt(const DnsAttempt* previous_attempt) {
DCHECK(previous_attempt);
DCHECK(!had_tcp_attempt_);
unsigned server_index = previous_attempt->server_index();
std::unique_ptr<StreamSocket> socket(
session_->CreateTCPSocket(server_index, net_log_.source()));
// TODO(szym): Reuse the same id to help the server?
uint16_t id = session_->NextQueryId();
std::unique_ptr<DnsQuery> query =
previous_attempt->GetQuery()->CloneWithNewId(id);
RecordLostPacketsIfAny();
// Cancel all other attempts that have not received a response, no point
// waiting on them.
for (auto it = attempts_.begin(); it != attempts_.end();) {
if (!(*it)->is_completed())
it = attempts_.erase(it);
else
++it;
}
unsigned attempt_number = attempts_.size();
DnsTCPAttempt* attempt =
new DnsTCPAttempt(server_index, std::move(socket), std::move(query));
attempts_.push_back(base::WrapUnique(attempt));
++attempts_count_;
had_tcp_attempt_ = true;
net_log_.AddEvent(
NetLogEventType::DNS_TRANSACTION_TCP_ATTEMPT,
attempt->GetSocketNetLog().source().ToEventParametersCallback());
int rv = attempt->Start(base::Bind(&DnsTransactionImpl::OnAttemptComplete,
base::Unretained(this), attempt_number));
if (rv == ERR_IO_PENDING) {
// Custom timeout for TCP attempt.
base::TimeDelta timeout = timer_.GetCurrentDelay() * 2;
timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
}
return AttemptResult(rv, attempt);
}
// Begins query for the current name. Makes the first attempt.
AttemptResult StartQuery() {
std::string dotted_qname = DNSDomainToString(qnames_.front());
net_log_.BeginEvent(NetLogEventType::DNS_TRANSACTION_QUERY,
NetLog::StringCallback("qname", &dotted_qname));
first_server_index_ = session_->config().nameservers.empty()
? 0
: session_->NextFirstServerIndex();
RecordLostPacketsIfAny();
attempts_.clear();
had_tcp_attempt_ = false;
return MakeAttempt();
}
void OnUdpAttemptComplete(unsigned attempt_number,
base::TimeTicks start,
int rv) {
DCHECK_LT(attempt_number, attempts_.size());
const DnsAttempt* attempt = attempts_[attempt_number].get();
if (attempt->GetResponse()) {
session_->RecordRTT(attempt->server_index(),
base::TimeTicks::Now() - start);
}
OnAttemptComplete(attempt_number, rv);
}
void OnAttemptComplete(unsigned attempt_number, int rv) {
if (callback_.is_null())
return;
DCHECK_LT(attempt_number, attempts_.size());
const DnsAttempt* attempt = attempts_[attempt_number].get();
AttemptResult result = ProcessAttemptResult(AttemptResult(rv, attempt));
if (result.rv != ERR_IO_PENDING)
DoCallback(result);
}
// Record packet loss for any incomplete attempts.
void RecordLostPacketsIfAny() {
// Loop through attempts until we find first that is completed
size_t first_completed = 0;
for (first_completed = 0; first_completed < attempts_.size();
++first_completed) {
if (attempts_[first_completed]->is_completed())
break;
}
// If there were no completed attempts, then we must be offline, so don't
// record any attempts as lost packets.
if (first_completed == attempts_.size())
return;
size_t num_servers = session_->config().nameservers.size() +
session_->config().dns_over_https_servers.size();
std::vector<int> server_attempts(num_servers);
for (size_t i = 0; i < first_completed; ++i) {
unsigned server_index = attempts_[i]->server_index();
int server_attempt = server_attempts[server_index]++;
// Don't record lost packet unless attempt is in pending state.
if (!attempts_[i]->is_pending())
continue;
session_->RecordLostPacket(server_index, server_attempt);
}
}
void LogResponse(const DnsAttempt* attempt) {
if (attempt && attempt->GetResponse()) {
net_log_.AddEvent(NetLogEventType::DNS_TRANSACTION_RESPONSE,
base::Bind(&DnsAttempt::NetLogResponseCallback,
base::Unretained(attempt)));
}
}
bool MoreAttemptsAllowed() const {
if (had_tcp_attempt_)
return false;
const DnsConfig& config = session_->config();
return attempts_.size() < config.attempts * config.nameservers.size() +
config.dns_over_https_servers.size();
}
// Resolves the result of a DnsAttempt until a terminal result is reached
// or it will complete asynchronously (ERR_IO_PENDING).
AttemptResult ProcessAttemptResult(AttemptResult result) {
while (result.rv != ERR_IO_PENDING) {
LogResponse(result.attempt);
switch (result.rv) {
case OK:
if (!doh_attempt_)
session_->RecordServerSuccess(result.attempt->server_index());
net_log_.EndEventWithNetErrorCode(
NetLogEventType::DNS_TRANSACTION_QUERY, result.rv);
DCHECK(result.attempt);
DCHECK(result.attempt->GetResponse());
return result;
case ERR_NAME_NOT_RESOLVED:
session_->RecordServerSuccess(result.attempt->server_index());
net_log_.EndEventWithNetErrorCode(
NetLogEventType::DNS_TRANSACTION_QUERY, result.rv);
// Try next suffix. Check that qnames_ isn't already empty first,
// which can happen when there are two attempts running at once.
// TODO(mgersh): remove this workaround for https://crbug.com/774846
// when https://crbug.com/779589 is fixed.
if (!qnames_.empty())
qnames_.pop_front();
if (qnames_.empty()) {
return result;
} else {
result = StartQuery();
}
break;
case ERR_CONNECTION_REFUSED:
case ERR_DNS_TIMED_OUT:
if (result.attempt)
session_->RecordServerFailure(result.attempt->server_index());
if (MoreAttemptsAllowed()) {
result = MakeAttempt();
} else {
return result;
}
break;
case ERR_DNS_SERVER_REQUIRES_TCP:
result = MakeTCPAttempt(result.attempt);
break;
default:
// Server failure.
DCHECK(result.attempt);
if (result.attempt != attempts_.back().get()) {
// This attempt already timed out. Ignore it.
session_->RecordServerFailure(result.attempt->server_index());
return AttemptResult(ERR_IO_PENDING, NULL);
}
if (MoreAttemptsAllowed()) {
result = MakeAttempt();
} else if (result.rv == ERR_DNS_MALFORMED_RESPONSE &&
!had_tcp_attempt_ && !doh_attempt_) {
// For UDP only, ignore the response and wait until the last
// attempt times out.
return AttemptResult(ERR_IO_PENDING, NULL);
} else {
return AttemptResult(result.rv, NULL);
}
break;
}
}
return result;
}
void OnTimeout() {
if (callback_.is_null())
return;
DCHECK(!attempts_.empty());
AttemptResult result = ProcessAttemptResult(
AttemptResult(ERR_DNS_TIMED_OUT, attempts_.back().get()));
if (result.rv != ERR_IO_PENDING)
DoCallback(result);
}
scoped_refptr<DnsSession> session_;
std::string hostname_;
uint16_t qtype_;
const OptRecordRdata* opt_rdata_;
// Cleared in DoCallback.
DnsTransactionFactory::CallbackType callback_;
NetLogWithSource net_log_;
// Search list of fully-qualified DNS names to query next (in DNS format).
base::circular_deque<std::string> qnames_;
size_t qnames_initial_size_;
// List of attempts for the current name.
std::vector<std::unique_ptr<DnsAttempt>> attempts_;
// Count of attempts, not reset when |attempts_| vector is cleared.
int attempts_count_;
uint16_t doh_attempts_;
bool had_tcp_attempt_;
bool doh_attempt_;
// Index of the first server to try on each search query.
int first_server_index_;
base::OneShotTimer timer_;
URLRequestContext* url_request_context_;
RequestPriority request_priority_;
THREAD_CHECKER(thread_checker_);
DISALLOW_COPY_AND_ASSIGN(DnsTransactionImpl);
};
// ----------------------------------------------------------------------------
// Implementation of DnsTransactionFactory that returns instances of
// DnsTransactionImpl.
class DnsTransactionFactoryImpl : public DnsTransactionFactory {
public:
explicit DnsTransactionFactoryImpl(DnsSession* session) {
session_ = session;
}
std::unique_ptr<DnsTransaction> CreateTransaction(
const std::string& hostname,
uint16_t qtype,
CallbackType callback,
const NetLogWithSource& net_log) override {
return std::unique_ptr<DnsTransaction>(new DnsTransactionImpl(
session_.get(), hostname, qtype, callback, net_log, opt_rdata_.get()));
}
void AddEDNSOption(const OptRecordRdata::Opt& opt) override {
if (opt_rdata_ == nullptr)
opt_rdata_ = std::make_unique<OptRecordRdata>();
opt_rdata_->AddOpt(opt);
}
private:
scoped_refptr<DnsSession> session_;
std::unique_ptr<OptRecordRdata> opt_rdata_;
};
} // namespace
// static
std::unique_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
DnsSession* session) {
return std::unique_ptr<DnsTransactionFactory>(
new DnsTransactionFactoryImpl(session));
}
} // namespace net
| 33.342238 | 82 | 0.659737 | zipated |
b358f0e39672c1b32ccb75129cfa4116eaf8d54b | 408 | hpp | C++ | include/xtensor-fftw/xtensor-fftw_config.hpp | marty1885/xtensor-fftw | 968a36f204ed4328728705e1fd6f0c2961be7472 | [
"BSD-3-Clause"
] | null | null | null | include/xtensor-fftw/xtensor-fftw_config.hpp | marty1885/xtensor-fftw | 968a36f204ed4328728705e1fd6f0c2961be7472 | [
"BSD-3-Clause"
] | null | null | null | include/xtensor-fftw/xtensor-fftw_config.hpp | marty1885/xtensor-fftw | 968a36f204ed4328728705e1fd6f0c2961be7472 | [
"BSD-3-Clause"
] | null | null | null | /*
* xtensor-fftw
* Copyright (c) 2017, Patrick Bos
* Distributed under the terms of the BSD 3-Clause License.
*
* The full license is in the file LICENSE, distributed with this software.
*/
#ifndef XTENSOR_FFTW_CONFIG_HPP
#define XTENSOR_FFTW_CONFIG_HPP
#define XTENSOR_FFTW_VERSION_MAJOR 0
#define XTENSOR_FFTW_VERSION_MINOR 2
#define XTENSOR_FFTW_VERSION_PATCH 5
#endif //XTENSOR_FFTW_CONFIG_HPP
| 24 | 75 | 0.796569 | marty1885 |
b3598f74f568ce007d0dd421eb430c08521b6541 | 1,965 | cpp | C++ | src/primitives.cpp | kalakuer/TinyRayTracer | 99758f3e2e5279574e3850647d2541df2e111387 | [
"Apache-2.0"
] | null | null | null | src/primitives.cpp | kalakuer/TinyRayTracer | 99758f3e2e5279574e3850647d2541df2e111387 | [
"Apache-2.0"
] | null | null | null | src/primitives.cpp | kalakuer/TinyRayTracer | 99758f3e2e5279574e3850647d2541df2e111387 | [
"Apache-2.0"
] | null | null | null | #include "primitives.h"
#include <glm/gtc/matrix_transform.hpp>
namespace TinyRT {
IntersectTestResult Primitives::intersectTest(const Ray &ray, float refractiveIndex) {
glm::vec3 normal = glm::normalize(glm::cross(V1-V0, V2-V1));
float A = normal.x;
float B = normal.y;
float C = normal.z;
float D = -A*V0.x - B * V0.y - C * V0.z;
//Plane equation: Ax + By + Cz + D = 0
glm::vec3 rayOrigin = ray.origin();
glm::vec3 rayDirection = glm::normalize(ray.direction());
float t = -(D + A * rayOrigin.x + B * rayOrigin.y + C * rayOrigin.z) /
(A * rayDirection.x + B * rayDirection.y + C * rayDirection.z);
//check if ray intersect with plant
if(t <= 0 || glm::dot(rayDirection , normal) >= 0) {
IntersectTestResult result;
result.Intersected = false;
return result;
}
glm::vec3 intersectedPoint = rayOrigin + rayDirection * t;
//check if intersect point is in triangle
glm::vec3 PV0 = V0 - intersectedPoint;
glm::vec3 PV1 = V1 - intersectedPoint;
glm::vec3 PV2 = V2 - intersectedPoint;
float S0 = glm::length(glm::cross(V1-V0, V2-V0));
float S1 = glm::length(glm::cross(PV0, PV1)) +
glm::length(glm::cross(PV0, PV2)) +
glm::length(glm::cross(PV1, PV2));
IntersectTestResult result;
result.distance = t;
if(abs(S0-S1)<0.0001) {
result.Intersected = true;
result.IntersectedPoint = intersectedPoint;
result.PrimitivesNormal = normal;
result.ReflectionDirection = -glm::normalize(glm::reflect(normal, ray.direction()));
//TODO:RefractionDirection
return result;
} else {
result.Intersected = false;
return result;
}
}
}
| 33.87931 | 97 | 0.545547 | kalakuer |
b35aff00167f1f45d0c563466d09d90065a798ed | 4,664 | cpp | C++ | cpp/TCPDataTracker.cpp | jinyyu/filedump | 72b55e4ed260585a754078dc9623ff2fbbe5d9fc | [
"MIT"
] | null | null | null | cpp/TCPDataTracker.cpp | jinyyu/filedump | 72b55e4ed260585a754078dc9623ff2fbbe5d9fc | [
"MIT"
] | null | null | null | cpp/TCPDataTracker.cpp | jinyyu/filedump | 72b55e4ed260585a754078dc9623ff2fbbe5d9fc | [
"MIT"
] | null | null | null | #include "TCPDataTracker.h"
#include "debug_log.h"
#include <stdio.h>
#include <vector>
#include <map>
// As defined by RFC 1982 - 2 ^ (SERIAL_BITS - 1)
static const uint32_t k_seq_number_diff = 2147483648U;
static int seq_compare(uint32_t seq1, uint32_t seq2)
{
if (seq1 == seq2) {
return 0;
}
if (seq1 < seq2) {
return (seq2 - seq1 < k_seq_number_diff) ? -1 : 1;
}
else {
return (seq1 - seq2 > k_seq_number_diff) ? -1 : 1;
}
}
typedef std::vector<uint8_t> Payload;
typedef std::map<uint32_t, Payload> BufferPayload;
class TCPDataTracker
{
public:
explicit TCPDataTracker(uint32_t seq)
: next_seq_(seq),
ctx_(nullptr),
cb_(nullptr)
{
//LOG_DEBUG("new");
}
~TCPDataTracker()
{
//LOG_DEBUG("release");
}
void handle_data(uint32_t seq, const char* data, uint32_t len)
{
const uint32_t chunk_end = seq + len;
// If the end of the chunk ends before current sequence number, ignore it.
if (seq_compare(chunk_end, next_seq_) < 0) {
return;
}
// If it starts before our sequence number, slice it
if (seq_compare(seq, next_seq_) < 0) {
const uint32_t diff = next_seq_ - seq;
data += diff;
len -= diff;
seq = next_seq_;
}
if (seq == next_seq_) {
cb_(ctx_, data, len);
next_seq_ += len;
} else {
// Store this payload
store_payload(seq, data, len);
}
// Keep looping while the fragments seq is lower or equal to our seq
auto it = buffer_payload_.find(next_seq_);
while (it != buffer_payload_.end() && seq_compare(it->first, next_seq_) <= 0) {
// Does this fragment start before our sequence number?
if (seq_compare(it->first, next_seq_) < 0) {
uint32_t fragment_end = it->first + static_cast<uint32_t>(it->second.size());
int comparison = seq_compare(fragment_end, next_seq_);
// Does it end after our sequence number?
if (comparison > 0) {
// Then slice it
std::vector<uint8_t>& payload = it->second;
// First update this counter
uint32_t diff = next_seq_ - it->first;
const uint8_t* data = payload.data() + diff;
uint32_t len = payload.size() - diff;
store_payload(next_seq_, (const char*) data, len);
it = erase_iterator(it);
}
else {
// Otherwise, we've seen this part of the payload. Erase it.
it = erase_iterator(it);
}
}
else {
cb_(ctx_, (const char*) it->second.data(), static_cast<uint32_t>(it->second.size()));
next_seq_ += it->second.size();
it = erase_iterator(it);
}
}
}
void store_payload(uint32_t seq, const char* data, uint32_t len)
{
auto it = buffer_payload_.find(seq);
if (it == buffer_payload_.end()) {
Payload payload(data, data + len);
buffer_payload_[seq] = std::move(payload);
}
else if (it->second.size() < len) {
Payload payload(data, data + len);
it->second = std::move(payload);
}
}
BufferPayload::iterator erase_iterator(BufferPayload::iterator iter)
{
auto output = iter;
++output;
buffer_payload_.erase(iter);
if (output == buffer_payload_.end()) {
output = buffer_payload_.begin();
}
return output;
}
void set_callback(void* ctx, on_data_callback cb)
{
ctx_ = ctx;
cb_ = cb;
}
void update_seq(uint32_t seq)
{
next_seq_ = seq;
}
private:
uint32_t next_seq_;
void* ctx_;
on_data_callback cb_;
BufferPayload buffer_payload_;
};
void* new_tcp_data_tracker(uint32_t seq)
{
return new TCPDataTracker(seq);
}
void free_tcp_data_tracker(void* tracker)
{
delete ((TCPDataTracker*) tracker);
}
void tcp_data_tracker_set_callback(void* tracker, void* ctx, on_data_callback cb)
{
((TCPDataTracker*) tracker)->set_callback(ctx, cb);
}
void tcp_data_tracker_update_seq(void* tracker, uint32_t seq)
{
((TCPDataTracker*) tracker)->update_seq(seq);
}
void tcp_data_tracker_process_data(void* tracker, uint32_t seq, const char* data, uint32_t len)
{
((TCPDataTracker*) tracker)->handle_data(seq, data, len);
}
| 27.435294 | 101 | 0.560249 | jinyyu |
b35ebe999483687846a23f26268a5047aa1d474f | 1,075 | cpp | C++ | cpp/Dynamic-Programming/Longest-common-subsequence/Lcs-basic.cpp | fossabot/a-grim-loth | a6c8d549289a39ec981c1e0d0c754bb2708dfff9 | [
"MIT"
] | 4 | 2021-06-26T17:18:47.000Z | 2022-02-02T15:02:27.000Z | cpp/Dynamic-Programming/Longest-common-subsequence/Lcs-basic.cpp | fossabot/a-grim-loth | a6c8d549289a39ec981c1e0d0c754bb2708dfff9 | [
"MIT"
] | 8 | 2021-06-29T07:00:32.000Z | 2021-12-01T11:26:22.000Z | cpp/Dynamic-Programming/Longest-common-subsequence/Lcs-basic.cpp | fossabot/a-grim-loth | a6c8d549289a39ec981c1e0d0c754bb2708dfff9 | [
"MIT"
] | 3 | 2021-07-14T14:42:08.000Z | 2021-12-07T19:36:53.000Z | /**
* @file Lcs-basic.cpp
* @author prakash (prakashsellathurai@gmail.com)
* @brief
* @version 0.1
* @date 2021-08-28
*
* @copyright Copyright (c) 2021
*
*/
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
string s1 = "Hellollworld", s2 = "Hello";
int M = s1.length();
int N = s2.length();
int m[M + 1][N + 1];
for (int i = 0; i <= M; i++) {
for (int j = 0; j <= N; j++) {
if (i == 0 || j == 0) {
m[i][j] = 0;
continue;
}
if (s1[i] == s2[j])
m[i][j] = 1 + m[i - 1][j - 1];
else
m[i][j] = max(m[i][j - 1], m[i - 1][j]);
}
}
string str;
int i = M, j = N;
while (i > 0 && j > 0) {
if (s1[i - 1] == s2[j - 1]) {
str.push_back(s1[i - 1]);
i--;
j--;
}
else if (m[i][j - 1] < m[i - 1][j]) {
str.push_back(s2[j - 1]);
j--;
} else {
i--;
}
}
reverse(str.begin(), str.end());
std::cout << "Longest common subsequence : " << str << " " << m[M][N]
<< std::endl;
} | 18.534483 | 71 | 0.426977 | fossabot |
b3666723a500432b635c05f571fa68c1045e1aa5 | 3,287 | cc | C++ | tensorflow/lite/delegates/gpu/common/operation_parser.cc | TOT0RoKR/tensorflow | 12c2babf7dccc00c13d6e297c0f792f89f7408aa | [
"Apache-2.0"
] | 10 | 2021-05-25T17:43:04.000Z | 2022-03-08T10:46:09.000Z | tensorflow/lite/delegates/gpu/common/operation_parser.cc | CaptainGizzy21/tensorflow | 3457a2b122e50b4d44ceaaed5a663d635e5c22df | [
"Apache-2.0"
] | 1,056 | 2019-12-15T01:20:31.000Z | 2022-02-10T02:06:28.000Z | tensorflow/lite/delegates/gpu/common/operation_parser.cc | CaptainGizzy21/tensorflow | 3457a2b122e50b4d44ceaaed5a663d635e5c22df | [
"Apache-2.0"
] | 6 | 2016-09-07T04:00:15.000Z | 2022-01-12T01:47:38.000Z | /* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/lite/delegates/gpu/common/operation_parser.h"
#include <cstdint>
#include "absl/strings/str_cat.h"
#include "tensorflow/lite/c/common.h"
#include "tensorflow/lite/delegates/gpu/common/shape.h"
#include "tensorflow/lite/delegates/gpu/common/status.h"
namespace tflite {
namespace gpu {
absl::Status CheckKernels(int kernel_h, int kernel_w) {
if (kernel_h <= 0 || kernel_w <= 0) {
return absl::InvalidArgumentError(
absl::StrCat("Incorrect kernel values: kernel_height = ", kernel_h,
", kernel_width = ", kernel_w));
}
return absl::OkStatus();
}
absl::Status CheckKernelsAndStrides(int kernel_h, int kernel_w, int strides_h,
int strides_w) {
RETURN_IF_ERROR(CheckKernels(kernel_h, kernel_w));
RETURN_IF_ERROR(CheckStrides(strides_h, strides_w));
return absl::OkStatus();
}
absl::Status CheckMaxSupportedOpVersion(const TfLiteRegistration* registration,
int max_version) {
const int op_version = registration->version;
if (op_version > max_version) {
return absl::UnimplementedError(
absl::StrCat("Max version supported: ", max_version,
". Requested version ", op_version, "."));
}
return absl::OkStatus();
}
absl::Status CheckStrides(int strides_h, int strides_w) {
if (strides_h <= 0 || strides_w <= 0) {
return absl::InvalidArgumentError(
absl::StrCat("Incorrect stride values: stride_height = ", strides_h,
", stride_width = ", strides_w));
}
return absl::OkStatus();
}
absl::Status CheckTensorIsAvailable(const TfLiteContext* context,
const TfLiteNode* tflite_node, int idx) {
// If tensor id is in range, it's guaranteed that it'll be available.
if (idx >= tflite_node->inputs->size) {
return absl::OutOfRangeError(
absl::StrCat("Requested index goes beyond array size: ", idx, " vs ",
idx, tflite_node->inputs->size));
}
return absl::OkStatus();
}
HW ToHW(int32_t h, int32_t w) { return HW(h > 0 ? h : 1, w > 0 ? w : 1); }
absl::Status ParsePoolingAttributes(const TfLitePoolParams* tf_options,
const BHWC& input_shape,
Pooling2DAttributes* attr) {
attr->kernel = ToHW(tf_options->filter_height, tf_options->filter_width);
attr->strides = ToHW(tf_options->stride_height, tf_options->stride_width);
UpdatePadding(tf_options->padding, input_shape, attr);
return absl::OkStatus();
}
} // namespace gpu
} // namespace tflite
| 37.352273 | 80 | 0.656526 | TOT0RoKR |
b3682353e7682eff7b35fd3e6e2feb0de205e93c | 378 | cpp | C++ | problem solving/picking-numbers.cpp | blog-a1/hackeRRank | 72923ee08c8759bd5a10ba6c390b6755fe2bd2e2 | [
"MIT"
] | 1 | 2021-01-13T11:52:27.000Z | 2021-01-13T11:52:27.000Z | problem solving/picking-numbers.cpp | blog-a1/hackeRRank | 72923ee08c8759bd5a10ba6c390b6755fe2bd2e2 | [
"MIT"
] | null | null | null | problem solving/picking-numbers.cpp | blog-a1/hackeRRank | 72923ee08c8759bd5a10ba6c390b6755fe2bd2e2 | [
"MIT"
] | null | null | null | #include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n,c=1,s=1;cin>>n;int a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a,a+n);
for(int i=0;i<n-1;i++)
{
for(int j=i+1;j<n;j++)
if(a[i]==a[j]||a[j]==a[i+1]+1) c++;
s=(s>c)?s:c;
c=1;
}
cout<<s<<endl;
return 0;
} | 21 | 55 | 0.410053 | blog-a1 |
b36d3c2e619a040d9a31b1363b02b4c860a2d2bf | 661 | cpp | C++ | QuastPlugin.cpp | movingpictures83/Quast | 54dc604a7cd4b564c0bd92b7aa30a0552c84a104 | [
"MIT"
] | null | null | null | QuastPlugin.cpp | movingpictures83/Quast | 54dc604a7cd4b564c0bd92b7aa30a0552c84a104 | [
"MIT"
] | null | null | null | QuastPlugin.cpp | movingpictures83/Quast | 54dc604a7cd4b564c0bd92b7aa30a0552c84a104 | [
"MIT"
] | null | null | null | #include "PluginManager.h"
#include <stdio.h>
#include <stdlib.h>
#include "QuastPlugin.h"
void QuastPlugin::input(std::string file) {
inputfile = file;
}
void QuastPlugin::run() {
}
void QuastPlugin::output(std::string file) {
// spades.py -o 02_Quast -1 $1 -2 $2 --careful
// assembly-stats -t ./All_assemblies/*.fasta > ./All_assemblies/00_Metrics_all_assemblies.txt
std::string command = "quast.py "+inputfile+"/*.fasta -o "+file+"; cp "+file+"/report.txt "+file+"/..";
std::cout << command << std::endl;
system(command.c_str());
}
PluginProxy<QuastPlugin> QuastPluginProxy = PluginProxy<QuastPlugin>("Quast", PluginManager::getInstance());
| 26.44 | 108 | 0.691377 | movingpictures83 |
b37071ac5ce2fb057bc33580817a79c11b09df5d | 3,360 | cpp | C++ | test/unit/io/sequence_file/sequence_file_record_test.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 283 | 2017-03-14T23:43:33.000Z | 2022-03-28T02:30:02.000Z | test/unit/io/sequence_file/sequence_file_record_test.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 2,754 | 2017-03-21T18:39:02.000Z | 2022-03-31T13:26:15.000Z | test/unit/io/sequence_file/sequence_file_record_test.cpp | joergi-w/seqan3 | b757646eee3cddf1f2487db8f1c9f3576ee37391 | [
"CC-BY-4.0",
"CC0-1.0"
] | 88 | 2017-03-20T12:43:42.000Z | 2022-03-17T08:56:13.000Z | // -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
#include <gtest/gtest.h>
#include <seqan3/alphabet/detail/debug_stream_alphabet.hpp>
#include <seqan3/alphabet/nucleotide/dna4.hpp>
#include <seqan3/alphabet/quality/phred42.hpp>
#include <seqan3/io/detail/record_like.hpp>
#include <seqan3/io/sequence_file/record.hpp>
#include <seqan3/test/expect_range_eq.hpp>
#include <seqan3/test/expect_same_type.hpp>
#include <seqan3/utility/tuple/concept.hpp>
#include <seqan3/utility/type_list/type_list.hpp>
using seqan3::operator""_dna4;
// ----------------------------------------------------------------------------
// record
// ----------------------------------------------------------------------------
struct sequence_record : public ::testing::Test
{
using types = seqan3::type_list<std::string, seqan3::dna4_vector>;
using types_as_ids = seqan3::fields<seqan3::field::id, seqan3::field::seq>;
using record_type = seqan3::sequence_record<types, types_as_ids>;
};
TEST_F(sequence_record, concept)
{
EXPECT_TRUE((seqan3::detail::record_like<record_type>));
}
TEST_F(sequence_record, definition_tuple_traits)
{
EXPECT_SAME_TYPE((std::tuple<std::string, seqan3::dna4_vector>), typename record_type::base_type);
EXPECT_SAME_TYPE(std::string, (std::tuple_element_t<0, record_type>));
EXPECT_SAME_TYPE(seqan3::dna4_vector, (std::tuple_element_t<1, record_type>));
EXPECT_EQ(std::tuple_size_v<record_type>, 2ul);
EXPECT_TRUE(seqan3::tuple_like<record_type>);
}
TEST_F(sequence_record, construction)
{
[[maybe_unused]] record_type r{"MY ID", "ACGT"_dna4};
}
TEST_F(sequence_record, get_by_index)
{
record_type r{"MY ID", "ACGT"_dna4};
EXPECT_EQ(std::get<0>(r), "MY ID");
EXPECT_RANGE_EQ(std::get<1>(r), "ACGT"_dna4);
}
TEST_F(sequence_record, get_by_type)
{
record_type r{"MY ID", "ACGT"_dna4};
EXPECT_EQ(std::get<std::string>(r), "MY ID");
EXPECT_RANGE_EQ(std::get<seqan3::dna4_vector>(r), "ACGT"_dna4);
}
TEST_F(sequence_record, get_by_member)
{
record_type r{"MY ID", "ACGT"_dna4};
EXPECT_EQ(r.id(), "MY ID");
EXPECT_RANGE_EQ(r.sequence(), "ACGT"_dna4);
}
TEST_F(sequence_record, member_types)
{
record_type r{"MY ID", "ACGT"_dna4};
EXPECT_SAME_TYPE(std::string &, decltype(r.id()));
EXPECT_SAME_TYPE(seqan3::dna4_vector &, decltype(r.sequence()));
EXPECT_SAME_TYPE(std::string const &, decltype(std::as_const(r).id()));
EXPECT_SAME_TYPE(seqan3::dna4_vector const &, decltype(std::as_const(r).sequence()));
EXPECT_SAME_TYPE(std::string &&, decltype(std::move(r).id()));
EXPECT_SAME_TYPE(seqan3::dna4_vector &&, decltype(std::move(r).sequence()));
EXPECT_SAME_TYPE(std::string const &&, decltype(std::move(std::as_const(r)).id()));
EXPECT_SAME_TYPE(seqan3::dna4_vector const &&, decltype(std::move(std::as_const(r)).sequence()));
}
| 35.744681 | 104 | 0.643155 | joergi-w |
b375c7a959fa66dc6180a694281a47efb0880cb0 | 220 | hh | C++ | tests/Titon/Test/Stub/Annotation/BarAnnotationStub.hh | ciklon-z/framework | cbf44729173d3a83b91a2b0a217c6b3827512e44 | [
"BSD-2-Clause"
] | 206 | 2015-01-02T20:01:12.000Z | 2021-04-15T09:49:56.000Z | tests/Titon/Test/Stub/Annotation/BarAnnotationStub.hh | ciklon-z/framework | cbf44729173d3a83b91a2b0a217c6b3827512e44 | [
"BSD-2-Clause"
] | 44 | 2015-01-02T06:03:43.000Z | 2017-11-20T18:29:06.000Z | tests/Titon/Test/Stub/Annotation/BarAnnotationStub.hh | titon/framework | cbf44729173d3a83b91a2b0a217c6b3827512e44 | [
"BSD-2-Clause"
] | 27 | 2015-01-03T05:51:29.000Z | 2022-02-21T13:50:40.000Z | <?hh // strict
namespace Titon\Test\Stub\Annotation;
use Titon\Annotation\Annotation;
class BarAnnotationStub extends Annotation {
public function __construct(public string $string, public int $int = 0): void {}
}
| 24.444444 | 84 | 0.759091 | ciklon-z |
b376788b34d9e64d5fdfec7cc798cde4d0028f10 | 2,328 | cpp | C++ | codeforces/766e.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | 1 | 2020-04-04T14:56:12.000Z | 2020-04-04T14:56:12.000Z | codeforces/766e.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | null | null | null | codeforces/766e.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
const int L = 20;
using Freq = array<int,L>;
struct Tree {
int n;
vector<vector<int>> g;
vector<int> sz, pa, depth, sta, fin, tour, a;
int tim;
vector<Freq> cnt;
Tree(int _n) : n(_n)
, g(n)
, sz(n)
, pa(n, -1)
, depth(n)
, sta(n)
, fin(n)
, a(n)
, cnt(n)
{
tour.reserve(n);
input();
tim = 0; basic_dfs(0);
}
inline void add(int u, int v) {
g[u].emplace_back(v);
g[v].emplace_back(u);
}
void input() {
for (auto& x: a) {
cin >> x;
}
for (int _ = 1; _ < n; _++) {
int x,y;
cin >> x >> y;
--x; --y; // to 0-based
add(x,y);
}
}
void basic_dfs(int u) {
if (pa[u] != -1) g[u].erase(find(g[u].begin(), g[u].end(), pa[u]));
sta[u] = tim++;
tour.emplace_back(u);
for (int& v: g[u]) {
pa[v] = u;
depth[v] = depth[u] + 1;
basic_dfs(v);
sz[u] += sz[v];
}
++sz[u];
fin[u] = tim;
}
void solve() {
ll res = 0;
fill(sz.begin(), sz.end(), 0);
// well bit-independent, by iter L first, only O(n) space
for (int _ = n-1; _ >= 0; _--) {
int u = tour[_];
int x = a[u];
for (int i = L-1; i >= 0; i--) {
if (x>>i&1) cnt[u][i]++;
}
res += x;
sz[u]++;
for (int v: g[u]) {
// convo
for (int i = L-1; i >= 0; i--) {
res += cnt[u][i] * (1ll<<i) * (sz[v] - cnt[v][i]);
res += cnt[v][i] * (1ll<<i) * (sz[u] - cnt[u][i]);
}
// merge
for (int i = L-1; i >= 0; i--) {
if (x>>i&1) cnt[u][i] += sz[v] - cnt[v][i];
else cnt[u][i] += cnt[v][i];
}
sz[u] += sz[v];
}
}
cout << res;
}
};
// key: focus one bit
void solve() {
int n; cin >> n;
Tree tr(n); tr.solve();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 23.515152 | 75 | 0.352234 | sogapalag |
b382b4a80e7c3c5a3e9a6e795322701b252c352c | 682 | hpp | C++ | include/api/InfoObject.hpp | bander9289/StratifyAPI | 9b45091aa71a4e5718047438ea4044c1fdc814a3 | [
"MIT"
] | 2 | 2016-05-21T03:09:19.000Z | 2016-08-27T03:40:51.000Z | include/api/InfoObject.hpp | bander9289/StratifyAPI | 9b45091aa71a4e5718047438ea4044c1fdc814a3 | [
"MIT"
] | 75 | 2017-10-08T22:21:19.000Z | 2020-03-30T21:13:20.000Z | include/api/InfoObject.hpp | StratifyLabs/StratifyLib | 975a5c25a84296fd0dec64fe4dc579cf7027abe6 | [
"MIT"
] | 5 | 2018-03-27T16:44:09.000Z | 2020-07-08T16:45:55.000Z | /*! \file */ // Copyright 2011-2020 Tyler Gilbert and Stratify Labs, Inc; see LICENSE.md for rights.
#ifndef API_INFO_OBJECT_HPP
#define API_INFO_OBJECT_HPP
#include "ApiObject.hpp"
namespace api {
/*! \brief Information Object
* \details Classes that inherit from
* information objects are used for static
* data storage and access. They don't do any
* work that could cause errors.
*
*
* \sa api::WorkObject
*
*
*/
class InfoObject : public virtual ApiObject {
public:
virtual void * info_to_void(){ return 0; }
virtual const void * info_to_void() const { return 0; }
virtual u32 info_size() const { return 0; }
protected:
};
}
#endif // API_INFO_OBJECT_HPP
| 19.485714 | 100 | 0.714076 | bander9289 |
b384be169d0145722b946a25561ad6989f50479b | 6,544 | cpp | C++ | CorsixTH/Src/th_map_overlays.cpp | terrorcide/CorsixTH | 2d91936656529c26d21e2de41f4ea6a831bb4e47 | [
"MIT"
] | null | null | null | CorsixTH/Src/th_map_overlays.cpp | terrorcide/CorsixTH | 2d91936656529c26d21e2de41f4ea6a831bb4e47 | [
"MIT"
] | null | null | null | CorsixTH/Src/th_map_overlays.cpp | terrorcide/CorsixTH | 2d91936656529c26d21e2de41f4ea6a831bb4e47 | [
"MIT"
] | null | null | null | /*
Copyright (c) 2010 Peter "Corsix" Cawley
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.
*/
#include "th_map_overlays.h"
#include "th_gfx.h"
#include "th_map.h"
#include <sstream>
map_overlay_pair::map_overlay_pair()
{
first = nullptr;
second = nullptr;
owns_first = false;
owns_second = false;
}
map_overlay_pair::~map_overlay_pair()
{
set_first(nullptr, false);
set_second(nullptr, false);
}
void map_overlay_pair::set_first(map_overlay* pOverlay, bool bTakeOwnership)
{
if(first && owns_first)
delete first;
first = pOverlay;
owns_first = bTakeOwnership;
}
void map_overlay_pair::set_second(map_overlay* pOverlay, bool bTakeOwnership)
{
if(second && owns_second)
delete second;
second = pOverlay;
owns_second = bTakeOwnership;
}
void map_overlay_pair::draw_cell(render_target* pCanvas, int iCanvasX,
int iCanvasY, const level_map* pMap, int iNodeX,
int iNodeY)
{
if(first)
first->draw_cell(pCanvas, iCanvasX, iCanvasY, pMap, iNodeX, iNodeY);
if(second)
second->draw_cell(pCanvas, iCanvasX, iCanvasY, pMap, iNodeX, iNodeY);
}
map_text_overlay::map_text_overlay()
{
background_sprite = 0;
}
void map_text_overlay::set_background_sprite(size_t iSprite)
{
background_sprite = iSprite;
}
void map_text_overlay::draw_cell(render_target* pCanvas, int iCanvasX,
int iCanvasY, const level_map* pMap, int iNodeX,
int iNodeY)
{
if(sprites && background_sprite)
{
sprites->draw_sprite(pCanvas, background_sprite, iCanvasX,
iCanvasY, 0);
}
if(font)
{
draw_text(pCanvas, iCanvasX, iCanvasY, get_text(pMap, iNodeX, iNodeY));
}
}
const std::string map_positions_overlay::get_text(const level_map* pMap, int iNodeX, int iNodeY)
{
std::ostringstream str;
str << iNodeX + 1 << ',' << iNodeY + 1;
return str.str();
}
map_typical_overlay::map_typical_overlay()
{
sprites = nullptr;
font = nullptr;
owns_sprites = false;
owns_font = false;
}
map_typical_overlay::~map_typical_overlay()
{
set_sprites(nullptr, false);
set_font(nullptr, false);
}
void map_flags_overlay::draw_cell(render_target* pCanvas, int iCanvasX,
int iCanvasY, const level_map* pMap, int iNodeX,
int iNodeY)
{
const map_tile *pNode = pMap->get_tile(iNodeX, iNodeY);
if(!pNode)
return;
if(sprites)
{
if(pNode->flags.passable)
sprites->draw_sprite(pCanvas, 3, iCanvasX, iCanvasY, 0);
if(pNode->flags.hospital)
sprites->draw_sprite(pCanvas, 8, iCanvasX, iCanvasY, 0);
if(pNode->flags.buildable)
sprites->draw_sprite(pCanvas, 9, iCanvasX, iCanvasY, 0);
if(pNode->flags.can_travel_n && pMap->get_tile(iNodeX, iNodeY - 1)->flags.passable)
{
sprites->draw_sprite(pCanvas, 4, iCanvasX, iCanvasY, 0);
}
if(pNode->flags.can_travel_e && pMap->get_tile(iNodeX + 1, iNodeY)->flags.passable)
{
sprites->draw_sprite(pCanvas, 5, iCanvasX, iCanvasY, 0);
}
if(pNode->flags.can_travel_s && pMap->get_tile(iNodeX, iNodeY + 1)->flags.passable)
{
sprites->draw_sprite(pCanvas, 6, iCanvasX, iCanvasY, 0);
}
if(pNode->flags.can_travel_w && pMap->get_tile(iNodeX - 1, iNodeY)->flags.passable)
{
sprites->draw_sprite(pCanvas, 7, iCanvasX, iCanvasY, 0);
}
}
if(font)
{
if(!pNode->objects.empty())
{
std::ostringstream str;
str << 'T' << static_cast<int>(pNode->objects.front());
draw_text(pCanvas, iCanvasX, iCanvasY - 8, str.str());
}
if(pNode->iRoomId)
{
std::ostringstream str;
str << 'R' << static_cast<int>(pNode->iRoomId);
draw_text(pCanvas, iCanvasX, iCanvasY + 8, str.str());
}
}
}
void map_parcels_overlay::draw_cell(render_target* pCanvas, int iCanvasX,
int iCanvasY, const level_map* pMap, int iNodeX,
int iNodeY)
{
const map_tile *pNode = pMap->get_tile(iNodeX, iNodeY);
if(!pNode)
return;
if(font)
draw_text(pCanvas, iCanvasX, iCanvasY, std::to_string((int)pNode->iParcelId));
if(sprites)
{
uint16_t iParcel = pNode->iParcelId;
#define DIR(dx, dy, sprite) \
pNode = pMap->get_tile(iNodeX + dx, iNodeY + dy); \
if(!pNode || pNode->iParcelId != iParcel) \
sprites->draw_sprite(pCanvas, sprite, iCanvasX, iCanvasY, 0)
DIR( 0, -1, 18);
DIR( 1, 0, 19);
DIR( 0, 1, 20);
DIR(-1, 0, 21);
#undef DIR
}
}
void map_typical_overlay::draw_text(render_target* pCanvas, int iX, int iY,
std::string str)
{
text_layout oArea = font->get_text_dimensions(str.c_str(), str.length());
font->draw_text(pCanvas, str.c_str(), str.length(), iX + (64 - oArea.end_x) / 2,
iY + (32 - oArea.end_y) / 2);
}
void map_typical_overlay::set_sprites(sprite_sheet* pSheet, bool bTakeOwnership)
{
if(sprites && owns_sprites)
delete sprites;
sprites = pSheet;
owns_sprites = bTakeOwnership;
}
void map_typical_overlay::set_font(::font* font, bool take_ownership)
{
if(this->font && owns_font)
delete this->font;
this->font = font;
owns_font = take_ownership;
}
| 31.014218 | 96 | 0.636767 | terrorcide |
b387b1e4fc48981995d85dc01f36e5d93b923c28 | 8,733 | hpp | C++ | nodec/include/nodec/entities/sparse_table.hpp | ContentsViewer/nodec | 40b414a2f48d2e4718b69e0fa630e3f85e90e083 | [
"Apache-2.0"
] | 2 | 2022-01-03T12:01:03.000Z | 2022-01-04T18:11:25.000Z | nodec/include/nodec/entities/sparse_table.hpp | ContentsViewer/nodec | 40b414a2f48d2e4718b69e0fa630e3f85e90e083 | [
"Apache-2.0"
] | null | null | null | nodec/include/nodec/entities/sparse_table.hpp | ContentsViewer/nodec | 40b414a2f48d2e4718b69e0fa630e3f85e90e083 | [
"Apache-2.0"
] | null | null | null | #ifndef NODEC__ENTITIES__SPARSE_TABLE_HPP_
#define NODEC__ENTITIES__SPARSE_TABLE_HPP_
#include <nodec/logging.hpp>
#include <vector>
namespace nodec {
namespace entities {
// This code based on
// * <https://github.com/sparsehash/sparsehash/blob/master/src/sparsehash/sparsetable>
// Thank you! :)
/**
* The smaller this is, the faster lookup is (because the group bitmap is
* smaller) and the faster insert it, because there's less to move.
* On the other hand, there are more groups.
*/
constexpr uint16_t DEFAULT_SPARSE_GROUP_SIZE = 48;
template<typename Table>
class TableIterator {
using GroupIterator = typename Table::Group::iterator;
public:
using value_type = typename Table::Group::Value;
using pointer = value_type*;
using reference = value_type&;
public:
TableIterator(Table* table, size_t group_num, GroupIterator group_iter)
: table_(table), group_num_(group_num), group_iter_(group_iter) {
}
TableIterator(const TableIterator& from)
: table_(from.table_), group_num_(from.group_num_), group_iter_(from.group_iter_) {
}
reference operator*() const {
return *group_iter_;
}
pointer operator->() const {
return group_iter_.operator->();
}
TableIterator& operator++() {
++group_iter_;
if (group_iter_ == table_->end(group_num_)
&& group_num_ + 1 < table_->group_count()) {
++group_num_;
group_iter_ = table_->begin(group_num_);
}
return *this;
}
TableIterator& operator--() {
if (group_iter_ == table_->begin(group_num_)
&& group_num_ > 0) {
--group_num_;
group_iter_ = table_->end(group_num_);
}
--group_iter_;
return *this;
}
bool operator==(const TableIterator& it) {
return table_ == it.table_
&& group_num_ == it.group_num_
&& group_iter_ == it.group_iter_;
}
bool operator!=(const TableIterator& it) {
return !(*this == it);
}
private:
Table* table_;
size_t group_num_;
GroupIterator group_iter_;
};
template<typename ValueT, uint16_t GROUP_SIZE>
class BasicSparseGroup {
public:
using Value = ValueT;
public:
using size_type = uint16_t;
using iterator = typename std::vector<Value>::iterator;
private:
/**
* @brief i bits to bytes (rounded down)
*/
static size_type bytebit(size_type i) { return i >> 3; }
/**
* @brief Gets the leftover bits with division by byte.
*/
static size_type modbit(size_type i) { return 1 << (i & 0x07); }
/**
* @brief Tests bucket i is occuoued or not.
*/
int bmtest(size_type i) const { return bitmap[bytebit(i)] & modbit(i); }
void bmset(size_type i) { bitmap[bytebit(i)] |= modbit(i); }
void bmclear(size_type i) { bitmap[bytebit(i)] &= ~modbit(i); }
static size_type bits_in_byte(uint8_t byte) {
static const uint8_t bits_in[256]{
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
};
return bits_in[byte];
}
public:
/*
* @brief We need a small function that tells us how many set bits there are
* in position 0..i-1 of the bitmap.
*/
static size_type pos_to_offset(const uint8_t* bm, size_type pos) {
size_type retval = 0;
// @note Condition pos > 8 is an optimization; convince yourself we
// give exactly the same result as if we had pos >= 8 here instead.
for (; pos > 8; pos -= 8) {
retval += bits_in_byte(*bm++);
}
return retval + bits_in_byte(*bm & ((1 << pos) - 1));
}
public:
iterator begin() { return group.begin(); }
iterator end() { return group.end(); }
size_type num_buckets() { return num_buckets_; }
bool contains(const size_type i) const {
return bmtest(i) != 0x00;
}
template<typename... Args>
std::pair<Value&, bool> emplace(const size_type i, Args&&... args) {
if (bmtest(i)) {
return { group[pos_to_offset(bitmap, i)], false };
}
auto offset = pos_to_offset(bitmap, i);
group.emplace(group.begin() + offset, std::forward<Args>(args)...);
++num_buckets_;
bmset(i);
return { group[offset], true };
}
const Value* try_get(const size_type i) const {
if (!bmtest(i)) {
return nullptr;
}
return &group[pos_to_offset(bitmap, i)];
}
Value* try_get(const size_type i) {
if (!bmtest(i)) {
return nullptr;
}
return &group[pos_to_offset(bitmap, i)];
}
bool erase(const size_type i) {
if (!bmtest(i)) {
return false;
}
auto offset = pos_to_offset(bitmap, i);
group.erase(group.begin() + offset);
--num_buckets_;
bmclear(i);
return true;
}
private:
std::vector<Value> group;
uint8_t bitmap[(GROUP_SIZE - 1) / 8 + 1]; // fancy math is so we round up
size_type num_buckets_; // limits GROUP_SIZE to 64KB
};
template<typename T, uint16_t GROUP_SIZE>
class BasicSparseTable {
public:
using Group = BasicSparseGroup<T, GROUP_SIZE>;
public:
using size_type = size_t;
using iterator = TableIterator<BasicSparseTable<T, GROUP_SIZE>>;
using local_iterator = typename Group::iterator;
public:
uint16_t pos_in_group(const size_type i) const {
return static_cast<uint16_t>(i % GROUP_SIZE);
}
size_type group_num(const size_type i) const {
return i / GROUP_SIZE;
}
Group* group_assured(size_type i) {
auto num = group_num(i);
if (!(num < groups.size())) {
groups.resize(num + 1);
}
//nodec:logging::DebugStream(__FILE__, __LINE__) << sizeof(Group) << " * " << groups.size();
return &groups[num];
}
const Group* group_if_exists(size_type i) const {
auto num = group_num(i);
if (!(num < groups.size())) {
return nullptr;
}
return &groups[num];
}
Group* group_if_exists(size_type i) {
auto num = group_num(i);
if (!(num < groups.size())) {
return nullptr;
}
return &groups[num];
}
bool has_group(size_type i) const {
return group_num(i) < groups.size();
}
iterator begin() {
return { this, 0, begin(0) };
}
iterator end() {
auto group_num = groups.size() - 1;
return { this, group_num, end(group_num) };
}
T& operator[](const size_type i) {
return group_assured(i)->emplace(pos_in_group(i)).first;
}
const T* try_get(const size_type i) const {
auto* group = group_if_exists(i);
if (!group) {
return nullptr;
}
return group->try_get(pos_in_group(i));
}
T* try_get(const size_type i) {
auto* group = group_if_exists(i);
if (!group) {
return nullptr;
}
return group->try_get(pos_in_group(i));
}
bool erase(const size_type i) {
auto* group = group_if_exists(i);
if (!group) {
return false;
}
return group->erase(pos_in_group(i));
}
bool contains(const size_type i) const {
auto* group = group_if_exists(i);
if (!group) {
return false;
}
return group->contains(pos_in_group(i));
}
size_type group_count() const noexcept { return groups.size(); }
local_iterator begin(size_type n) {
return groups[n].begin();
}
local_iterator end(size_type n) {
return groups[n].end();
}
private:
std::vector<Group> groups;
};
template<typename T>
using SparseTable = BasicSparseTable<T, DEFAULT_SPARSE_GROUP_SIZE>;
}
}
#endif | 25.837278 | 100 | 0.557082 | ContentsViewer |
b389c12acbab075b6c2c19ac5d3e02b0a506f4c2 | 15,011 | cpp | C++ | master/core/third/libtorrent/src/tracker_manager.cpp | importlib/klib | a59837857689d0e60d3df6d2ebd12c3160efa794 | [
"MIT"
] | 4 | 2017-12-04T08:22:48.000Z | 2019-10-26T21:44:59.000Z | master/core/third/libtorrent/src/tracker_manager.cpp | isuhao/klib | a59837857689d0e60d3df6d2ebd12c3160efa794 | [
"MIT"
] | null | null | null | master/core/third/libtorrent/src/tracker_manager.cpp | isuhao/klib | a59837857689d0e60d3df6d2ebd12c3160efa794 | [
"MIT"
] | 4 | 2017-12-19T11:13:56.000Z | 2018-02-23T08:44:03.000Z | /*
Copyright (c) 2003, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#include "libtorrent/pch.hpp"
#include <vector>
#include <iostream>
#include <cctype>
#include <iomanip>
#include <sstream>
#include "zlib.h"
#include <boost/bind.hpp>
#include "libtorrent/tracker_manager.hpp"
#include "libtorrent/http_tracker_connection.hpp"
#include "libtorrent/udp_tracker_connection.hpp"
#include "libtorrent/entry.hpp"
#include "libtorrent/bencode.hpp"
#include "libtorrent/torrent.hpp"
#include "libtorrent/peer_connection.hpp"
using namespace libtorrent;
using boost::tuples::make_tuple;
using boost::tuples::tuple;
using boost::bind;
namespace
{
enum
{
minimum_tracker_response_length = 3,
http_buffer_size = 2048
};
enum
{
FTEXT = 0x01,
FHCRC = 0x02,
FEXTRA = 0x04,
FNAME = 0x08,
FCOMMENT = 0x10,
FRESERVED = 0xe0,
GZIP_MAGIC0 = 0x1f,
GZIP_MAGIC1 = 0x8b
};
}
namespace libtorrent
{
// returns -1 if gzip header is invalid or the header size in bytes
int gzip_header(const char* buf, int size)
{
TORRENT_ASSERT(buf != 0);
TORRENT_ASSERT(size > 0);
const unsigned char* buffer = reinterpret_cast<const unsigned char*>(buf);
const int total_size = size;
// The zip header cannot be shorter than 10 bytes
if (size < 10) return -1;
// check the magic header of gzip
if ((buffer[0] != GZIP_MAGIC0) || (buffer[1] != GZIP_MAGIC1)) return -1;
int method = buffer[2];
int flags = buffer[3];
// check for reserved flag and make sure it's compressed with the correct metod
if (method != Z_DEFLATED || (flags & FRESERVED) != 0) return -1;
// skip time, xflags, OS code
size -= 10;
buffer += 10;
if (flags & FEXTRA)
{
int extra_len;
if (size < 2) return -1;
extra_len = (buffer[1] << 8) | buffer[0];
if (size < (extra_len+2)) return -1;
size -= (extra_len + 2);
buffer += (extra_len + 2);
}
if (flags & FNAME)
{
while (size && *buffer)
{
--size;
++buffer;
}
if (!size || *buffer) return -1;
--size;
++buffer;
}
if (flags & FCOMMENT)
{
while (size && *buffer)
{
--size;
++buffer;
}
if (!size || *buffer) return -1;
--size;
++buffer;
}
if (flags & FHCRC)
{
if (size < 2) return -1;
size -= 2;
buffer += 2;
}
return total_size - size;
}
bool inflate_gzip(
std::vector<char>& buffer
, tracker_request const& req
, request_callback* requester
, int maximum_tracker_response_length)
{
TORRENT_ASSERT(maximum_tracker_response_length > 0);
int header_len = gzip_header(&buffer[0], (int)buffer.size());
if (header_len < 0)
{
requester->tracker_request_error(req, 200, "invalid gzip header in tracker response");
return true;
}
// start off wth one kilobyte and grow
// if needed
std::vector<char> inflate_buffer(1024);
// initialize the zlib-stream
z_stream str;
// subtract 8 from the end of the buffer since that's CRC32 and input size
// and those belong to the gzip file
str.avail_in = (int)buffer.size() - header_len - 8;
str.next_in = reinterpret_cast<Bytef*>(&buffer[header_len]);
str.next_out = reinterpret_cast<Bytef*>(&inflate_buffer[0]);
str.avail_out = (int)inflate_buffer.size();
str.zalloc = Z_NULL;
str.zfree = Z_NULL;
str.opaque = 0;
// -15 is really important. It will make inflate() not look for a zlib header
// and just deflate the buffer
if (inflateInit2(&str, -15) != Z_OK)
{
requester->tracker_request_error(req, 200, "gzip out of memory");
return true;
}
// inflate and grow inflate_buffer as needed
int ret = inflate(&str, Z_SYNC_FLUSH);
while (ret == Z_OK)
{
if (str.avail_out == 0)
{
if (inflate_buffer.size() >= (unsigned)maximum_tracker_response_length)
{
inflateEnd(&str);
requester->tracker_request_error(req, 200
, "tracker response too large");
return true;
}
int new_size = (int)inflate_buffer.size() * 2;
if (new_size > maximum_tracker_response_length) new_size = maximum_tracker_response_length;
int old_size = (int)inflate_buffer.size();
inflate_buffer.resize(new_size);
str.next_out = reinterpret_cast<Bytef*>(&inflate_buffer[old_size]);
str.avail_out = new_size - old_size;
}
ret = inflate(&str, Z_SYNC_FLUSH);
}
inflate_buffer.resize(inflate_buffer.size() - str.avail_out);
inflateEnd(&str);
if (ret != Z_STREAM_END)
{
requester->tracker_request_error(req, 200, "gzip error");
return true;
}
// commit the resulting buffer
std::swap(buffer, inflate_buffer);
return false;
}
std::string base64encode(const std::string& s)
{
static const char base64_table[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
unsigned char inbuf[3];
unsigned char outbuf[4];
std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();)
{
// available input is 1,2 or 3 bytes
// since we read 3 bytes at a time at most
int available_input = (std::min)(3, (int)std::distance(i, s.end()));
// clear input buffer
std::fill(inbuf, inbuf+3, 0);
// read a chunk of input into inbuf
for (int j = 0; j < available_input; ++j)
{
inbuf[j] = *i;
++i;
}
// encode inbuf to outbuf
outbuf[0] = (inbuf[0] & 0xfc) >> 2;
outbuf[1] = ((inbuf[0] & 0x03) << 4) | ((inbuf [1] & 0xf0) >> 4);
outbuf[2] = ((inbuf[1] & 0x0f) << 2) | ((inbuf [2] & 0xc0) >> 6);
outbuf[3] = inbuf[2] & 0x3f;
// write output
for (int j = 0; j < available_input+1; ++j)
{
ret += base64_table[outbuf[j]];
}
// write pad
for (int j = 0; j < 3 - available_input; ++j)
{
ret += '=';
}
}
return ret;
}
timeout_handler::timeout_handler(asio::strand& str)
: m_strand(str)
, m_start_time(time_now())
, m_read_time(time_now())
, m_timeout(str.io_service())
, m_completion_timeout(0)
, m_read_timeout(0)
, m_abort(false)
{}
void timeout_handler::set_timeout(int completion_timeout, int read_timeout)
{
m_completion_timeout = completion_timeout;
m_read_timeout = read_timeout;
m_start_time = m_read_time = time_now();
if (m_abort) return;
int timeout = (std::min)(
m_read_timeout, (std::min)(m_completion_timeout, m_read_timeout));
m_timeout.expires_at(m_read_time + seconds(timeout));
m_timeout.async_wait(m_strand.wrap(bind(
&timeout_handler::timeout_callback, self(), _1)));
}
void timeout_handler::restart_read_timeout()
{
m_read_time = time_now();
}
void timeout_handler::cancel()
{
m_abort = true;
m_completion_timeout = 0;
m_timeout.cancel();
}
void timeout_handler::timeout_callback(asio::error_code const& error) try
{
if (error) return;
if (m_completion_timeout == 0) return;
ptime now(time_now());
time_duration receive_timeout = now - m_read_time;
time_duration completion_timeout = now - m_start_time;
if (m_read_timeout
< total_seconds(receive_timeout)
|| m_completion_timeout
< total_seconds(completion_timeout))
{
on_timeout();
return;
}
if (m_abort) return;
int timeout = (std::min)(
m_read_timeout, (std::min)(m_completion_timeout, m_read_timeout));
m_timeout.expires_at(m_read_time + seconds(timeout));
m_timeout.async_wait(m_strand.wrap(
bind(&timeout_handler::timeout_callback, self(), _1)));
}
catch (std::exception&)
{
TORRENT_ASSERT(false);
}
tracker_connection::tracker_connection(
tracker_manager& man
, tracker_request const& req
, asio::strand& str
, address bind_interface_
, boost::weak_ptr<request_callback> r)
: timeout_handler(str)
, m_requester(r)
, m_bind_interface(bind_interface_)
, m_man(man)
, m_req(req)
{}
boost::shared_ptr<request_callback> tracker_connection::requester()
{
return m_requester.lock();
}
void tracker_connection::fail(int code, char const* msg)
{
boost::shared_ptr<request_callback> cb = requester();
if (cb) cb->tracker_request_error(m_req, code, msg);
close();
}
void tracker_connection::fail_timeout()
{
boost::shared_ptr<request_callback> cb = requester();
if (cb) cb->tracker_request_timed_out(m_req);
close();
}
void tracker_connection::close()
{
cancel();
m_man.remove_request(this);
}
void tracker_manager::remove_request(tracker_connection const* c)
{
mutex_t::scoped_lock l(m_mutex);
tracker_connections_t::iterator i = std::find(m_connections.begin()
, m_connections.end(), boost::intrusive_ptr<const tracker_connection>(c));
if (i == m_connections.end()) return;
m_connections.erase(i);
}
// returns protocol, auth, hostname, port, path
tuple<std::string, std::string, std::string, int, std::string>
parse_url_components(std::string url)
{
std::string hostname; // hostname only
std::string auth; // user:pass
std::string protocol; // should be http
int port = 80;
// PARSE URL
std::string::iterator start = url.begin();
// remove white spaces in front of the url
while (start != url.end() && (*start == ' ' || *start == '\t'))
++start;
std::string::iterator end
= std::find(url.begin(), url.end(), ':');
protocol.assign(start, end);
if (end == url.end()) throw std::runtime_error("invalid url '" + url + "'");
++end;
if (end == url.end()) throw std::runtime_error("invalid url '" + url + "'");
if (*end != '/') throw std::runtime_error("invalid url '" + url + "'");
++end;
if (end == url.end()) throw std::runtime_error("invalid url '" + url + "'");
if (*end != '/') throw std::runtime_error("invalid url '" + url + "'");
++end;
start = end;
std::string::iterator at = std::find(start, url.end(), '@');
std::string::iterator colon = std::find(start, url.end(), ':');
end = std::find(start, url.end(), '/');
if (at != url.end()
&& colon != url.end()
&& colon < at
&& at < end)
{
auth.assign(start, at);
start = at;
++start;
}
std::string::iterator port_pos;
// this is for IPv6 addresses
if (start != url.end() && *start == '[')
{
port_pos = std::find(start, url.end(), ']');
if (port_pos == url.end()) throw std::runtime_error("invalid hostname syntax '" + url + "'");
port_pos = std::find(port_pos, url.end(), ':');
}
else
{
port_pos = std::find(start, url.end(), ':');
}
if (port_pos < end)
{
hostname.assign(start, port_pos);
++port_pos;
try
{
port = boost::lexical_cast<int>(std::string(port_pos, end));
}
catch(boost::bad_lexical_cast&)
{
throw std::runtime_error("invalid url: \"" + url
+ "\", port number expected");
}
}
else
{
hostname.assign(start, end);
}
start = end;
return make_tuple(protocol, auth, hostname, port
, std::string(start, url.end()));
}
void tracker_manager::queue_request(
asio::strand& str
, connection_queue& cc
, tracker_request req
, std::string const& auth
, address bind_infc
, boost::weak_ptr<request_callback> c)
{
mutex_t::scoped_lock l(m_mutex);
TORRENT_ASSERT(req.num_want >= 0);
if (req.event == tracker_request::stopped)
req.num_want = 0;
TORRENT_ASSERT(!m_abort || req.event == tracker_request::stopped);
if (m_abort && req.event != tracker_request::stopped)
return;
try
{
std::string protocol;
std::string hostname;
int port;
std::string request_string;
using boost::tuples::ignore;
// TODO: should auth be used here?
boost::tie(protocol, ignore, hostname, port, request_string)
= parse_url_components(req.url);
boost::intrusive_ptr<tracker_connection> con;
if (protocol == "http")
{
con = new http_tracker_connection(
str
, cc
, *this
, req
, hostname
, port
, request_string
, bind_infc
, c
, m_settings
, m_proxy
, auth);
}
else if (protocol == "udp")
{
con = new udp_tracker_connection(
str
, *this
, req
, hostname
, port
, bind_infc
, c
, m_settings);
}
else
{
throw std::runtime_error("unkown protocol in tracker url");
}
m_connections.push_back(con);
boost::shared_ptr<request_callback> cb = con->requester();
if (cb) cb->m_manager = this;
}
catch (std::exception& e)
{
if (boost::shared_ptr<request_callback> r = c.lock())
r->tracker_request_error(req, -1, e.what());
}
}
void tracker_manager::abort_all_requests()
{
// removes all connections from m_connections
// except those with a requester == 0 (since those are
// 'event=stopped'-requests)
mutex_t::scoped_lock l(m_mutex);
m_abort = true;
tracker_connections_t keep_connections;
while (!m_connections.empty())
{
boost::intrusive_ptr<tracker_connection>& c = m_connections.back();
if (!c)
{
m_connections.pop_back();
continue;
}
tracker_request const& req = c->tracker_req();
if (req.event == tracker_request::stopped)
{
keep_connections.push_back(c);
m_connections.pop_back();
continue;
}
// close will remove the entry from m_connections
// so no need to pop
c->close();
}
std::swap(m_connections, keep_connections);
}
bool tracker_manager::empty() const
{
mutex_t::scoped_lock l(m_mutex);
return m_connections.empty();
}
int tracker_manager::num_requests() const
{
mutex_t::scoped_lock l(m_mutex);
return m_connections.size();
}
}
| 24.608197 | 96 | 0.651456 | importlib |
b38c0e0d9c3330e7bea5bd829fe6bbf9063acaf3 | 7,847 | cpp | C++ | vipster/step.py.cpp | hein09/vipster | b92302bf2bb8b8941e239ce8cbc7209e1e615b0b | [
"BSD-2-Clause"
] | 6 | 2015-12-02T15:33:27.000Z | 2017-07-28T17:46:51.000Z | vipster/step.py.cpp | hein09/vipster | b92302bf2bb8b8941e239ce8cbc7209e1e615b0b | [
"BSD-2-Clause"
] | 3 | 2018-02-04T16:11:19.000Z | 2018-03-16T16:23:29.000Z | vipster/step.py.cpp | hein09/vipster | b92302bf2bb8b8941e239ce8cbc7209e1e615b0b | [
"BSD-2-Clause"
] | 1 | 2017-07-05T11:44:55.000Z | 2017-07-05T11:44:55.000Z | #include "step.py.h"
#include "step.h"
#include <utility>
using namespace Vipster;
/* FIXME: Optimize assignment
*
* problems so far:
* - assignment from formatter not working as intended, library problem?
* - assignment to sub-steps not working, types mapped multiple times
* -> pybind/python can't deduce correct overload at RT
* - bindings are not templated -> confined to one atom_source hierarchy
*
* Possible solutions:
* - Introduce a standalone atom to allow for conversion between hierarchies
* (probably slow, but only when working within python)
* could also solve the problem of comparability
* - bind formatter/selection within bind_step so assignments can refer to concrete instances
* of the whole hierarchy (better)
* OR
* remove duplicate bindings via constexpr if and detail::is_selection/is_formatter (worse)
*/
template <typename S, typename A>
void __setitem__(S& s, int i, const A& at){
if (i<0){
i = i+static_cast<int>(s.getNat());
}
if ((i<0) || i>=static_cast<int>(s.getNat())){
throw py::index_error();
}
s[static_cast<size_t>(i)] = at;
}
template <typename S>
py::class_<S> bind_step(py::handle &m, std::string name){
py::class_<StepConst<typename S::atom_source>>(m, ("__"+name+"Base").c_str());
auto s = py::class_<S, StepConst<typename S::atom_source>>(m, name.c_str())
.def("getPTE", &S::getPTE)
.def_property("comment", &S::getComment, &S::setComment)
// Atoms
.def("__getitem__", [](S& s, int i){
if (i<0){
i = i+static_cast<int>(s.getNat());
}
if ((i<0) || i>=static_cast<int>(s.getNat())){
throw py::index_error();
}
return s[static_cast<size_t>(i)];
}, py::keep_alive<0, 1>())
.def("__setitem__", __setitem__<S, typename S::atom>)
.def("__setitem__", __setitem__<S, typename S::formatter::atom>)
.def("__setitem__", __setitem__<S, typename S::selection::atom>)
.def("__setitem__", __setitem__<S, typename S::formatter::selection::atom>)
.def("__len__", &S::getNat)
.def_property_readonly("nat", &S::getNat)
.def("__iter__", [](S& s){return py::make_iterator(s.begin(), s.end());})
// TYPES
.def("getTypes", [](const S& s){
auto oldT = s.getTypes();
return std::vector<std::string>(oldT.begin(), oldT.end());
})
.def_property_readonly("ntyp", &S::getNtyp)
// FMT
.def_property_readonly("fmt", &S::getFmt)
.def("asFmt", py::overload_cast<AtomFmt>(&S::asFmt), "fmt"_a)
// CELL
.def_property_readonly("hasCell", &S::hasCell)
.def("getCellDim", &S::getCellDim)
.def("getCellVec", &S::getCellVec)
.def("getCom", py::overload_cast<>(&S::getCom, py::const_))
.def("getCom", py::overload_cast<AtomFmt>(&S::getCom, py::const_), "fmt"_a)
.def("getCenter", &S::getCenter, "fmt"_a, "com"_a)
// BONDS
.def("getBonds", [](const S& s, bool update){
if(update){
s.generateBonds();
}
return s.getBonds();
}, "update"_a=true)
.def("generateBonds", &S::generateBonds, "overlap_only"_a=false)
.def("getOverlaps", &S::getOverlaps)
.def("getTopology", &S::getTopology, "angles"_a=true, "dihedrals"_a=true, "impropers"_a=true)
// SELECTION
.def("select", [](S &s, const std::string &sel){return s.select(sel);}, "selection"_a)
// Modification functions
.def("modShift", &S::modShift, "shift"_a, "factor"_a=1.0f)
.def("modRotate", &S::modRotate, "angle"_a, "axis"_a, "shift"_a=Vec{})
.def("modMirror", &S::modMirror, "axis1"_a, "axis1"_a, "shift"_a=Vec{})
;
using Atom = typename S::atom;
using _Vec = decltype(std::declval<typename S::atom>().coord);
auto a = py::class_<Atom>(s, "Atom")
.def_property("name", [](const Atom &a)->const std::string&{return a.name;},
[](Atom &a, const std::string &s){a.name = s;})
.def_property("coord", [](const Atom &a)->const _Vec&{return a.coord;},
[](Atom &a, Vec c){a.coord = c;})
.def_property("properties", [](const Atom &a)->const AtomProperties&{return a.properties;},
[](Atom &a, const AtomProperties &bs){a.properties = bs;})
// .def("__eq__", [](const Atom &lhs, const Atom &rhs){return lhs == rhs;},py::is_operator())
// .def(py::self == py::self)
// .def(py::self != py::self)
;
py::class_<_Vec>(a, "_Vec")
.def("__getitem__", [](const _Vec& v, int i) -> Vec::value_type{
if (i<0) {
i += 3;
}
if ((i<0) || (i>=3)) {
throw py::index_error();
}
return v[i];
})
.def("__setitem__", [](_Vec& v, int i, Vec::value_type val){
if (i<0) {
i += 3;
}
if ((i<0) || (i>=3)) {
throw py::index_error();
}
v[i] = val;
}, py::keep_alive<0, 1>())
.def("__repr__", [name](const _Vec& v){
return name + "::Atom::Vec["
+ std::to_string(v[0]) + ", "
+ std::to_string(v[1]) + ", "
+ std::to_string(v[2]) + "]";
})
.def(py::self == py::self)
.def(py::self == Vec())
;
return s;
}
void Vipster::Py::Step(py::module& m){
auto s = bind_step<Vipster::Step>(m, "Step")
.def(py::init<AtomFmt, std::string>(), "fmt"_a=AtomFmt::Angstrom, "comment"_a="")
// Format
.def("setFmt", &Step::setFmt, "fmt"_a, "scale"_a=true)
// Atoms
.def("newAtom", [](Vipster::Step& s, std::string name, Vec coord, AtomProperties prop){
s.newAtom(name, coord, prop);},
"name"_a="", "coord"_a=Vec{}, "properties"_a=AtomProperties{})
.def("newAtom", [](Vipster::Step& s, const Step::atom& at){s.newAtom(at);}, "at"_a)
.def("newAtom", [](Vipster::Step& s, const Step::formatter::atom& at){s.newAtom(at);}, "at"_a)
.def("newAtom", [](Vipster::Step& s, const Step::selection::atom& at){s.newAtom(at);}, "at"_a)
.def("newAtom", [](Vipster::Step& s, const Step::selection::formatter::atom& at){s.newAtom(at);}, "at"_a)
.def("newAtoms", [](Vipster::Step& s, size_t i){s.newAtoms(i);}, "i"_a)
.def("newAtoms", [](Vipster::Step& s, const Vipster::Step& rhs){s.newAtoms(rhs);}, "step"_a)
.def("newAtoms", [](Vipster::Step& s, const Vipster::Step::formatter& rhs){s.newAtoms(rhs);}, "step"_a)
.def("newAtoms", [](Vipster::Step& s, const Vipster::Step::selection& rhs){s.newAtoms(rhs);}, "step"_a)
.def("newAtoms", [](Vipster::Step& s, const Vipster::Step::selection::formatter& rhs){s.newAtoms(rhs);}, "step"_a)
.def("delAtom", [](Vipster::Step& s, size_t i){s.delAtom(i);}, "i"_a)
// CELL
.def("enableCell", &Vipster::Step::enableCell, "val"_a)
.def("setCellDim", &Vipster::Step::setCellDim, "cdm"_a, "fmt"_a, "scale"_a=false)
.def("setCellVec", &Vipster::Step::setCellVec, "vec"_a, "scale"_a=false)
// Modification functions
.def("modWrap", &Step::modWrap)
.def("modCrop", &Step::modCrop)
.def("modMultiply", &Step::modMultiply, "x"_a, "y"_a, "z"_a)
.def("modAlign", &Step::modAlign, "step_dir"_a, "target_dir"_a)
.def("modReshape", &Step::modReshape, "newMat"_a, "newCdm"_a, "cdmFmt"_a)
;
auto sf = bind_step<Vipster::Step::formatter>(s, "__Formatter");
bind_step<Vipster::Step::selection>(s, "__Selection");
bind_step<Vipster::Step::formatter::selection>(sf, "__Selection");
}
| 44.84 | 122 | 0.555626 | hein09 |
b38c2e19bf96086a24c3d4f449fe5f95e7ff26e9 | 10,382 | cpp | C++ | Source/Constraint/constraint_length.cpp | neonkingfr/wildogcad | 6d9798daa672d3ab293579439f38bb279fa376c7 | [
"BSD-3-Clause"
] | null | null | null | Source/Constraint/constraint_length.cpp | neonkingfr/wildogcad | 6d9798daa672d3ab293579439f38bb279fa376c7 | [
"BSD-3-Clause"
] | null | null | null | Source/Constraint/constraint_length.cpp | neonkingfr/wildogcad | 6d9798daa672d3ab293579439f38bb279fa376c7 | [
"BSD-3-Clause"
] | null | null | null | /*******************************************************************************
* Copyright (c) 2007, 2008, CerroKai Development
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of CerroKai Development nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY CerroKai Development ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL CerroKai Development BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************/
/*** Included Header Files ***/
#include <Constraint/constraint_length.h>
#include <Sketcher/sketch.h>
#include <Sketcher/sketch_line.h>
#include <Kernel/document.h>
#include <Kernel/unit_types.h>
#include <PartDesign/part_plane.h>
/***********************************************~***************************************************/
void WCConstraintLength::GenerateMeasure(const WPFloat &offset, const WPFloat &labelOffset) {
//Set the measure label
std::string label = this->_line->Document()->LengthUnit()->DisplayString(this->_length, 4);
//Check to see if old measure needs to be deleted
if (this->_measure != NULL) delete this->_measure;
//Create the rendering measure
WCVector4 p0( this->_line->Base()->Begin() );
WCVector4 p1( this->_line->Base()->End() );
this->_measure = new WCConstraintMeasureTwoPoint(this, label, WCMeasureType::Absolute(), p0, p1,
this->_sketch->ReferencePlane()->InverseTransformMatrix(),
this->_sketch->ReferencePlane()->TransformMatrix(), offset, labelOffset);
}
void WCConstraintLength::Initialize(void) {
//Retain the line
this->_line->Retain(*this);
//Create the length controller
this->_controller = new WCConstraintLengthController(this);
//Add into sketch
if (!this->_sketch->AddConstraint(this)) {
CLOGGER_ERROR(WCLogManager::RootLogger(), "WCConstraintLength::WCConstraintLength - Problem adding constraint to sketch.");
//Should delete base
//throw error
return;
}
//Create the measure
this->GenerateMeasure(0.25*this->_length, 0.5);
//Create tree element and add into the tree (beneath the sketch features element)
WSTexture* constraintIcon = this->_document->Scene()->TextureManager()->TextureFromName("constraint32");
this->_treeElement = new WCTreeElement( this->_sketch->Document()->TreeView(), this->_name, this->_controller, constraintIcon);
this->_sketch->ConstraintsTreeElement()->AddLastChild(this->_treeElement);
//Inject constraints into sketch planner
this->InjectConstraints(this->_sketch->ConstraintPlanner());
}
/***********************************************~***************************************************/
WCConstraintLength::WCConstraintLength(WCSketch *sketch, const std::string &name, WCSketchLine *line) : ::WCSketchConstraint(sketch, name),
_line(line), _length(0.0), _measure(NULL) {
//Create the length controller
this->_controller = new WCConstraintLengthController(this);
//Make sure base is not null
if ((this->_line == NULL) || (this->_controller == NULL)) {
CLOGGER_ERROR(WCLogManager::RootLogger(), "WCConstraintLength::WCConstraintLength - NULL Line or controller.");
//throw error
return;
}
//Calcuate length of line
WCVector4 p0( this->_line->Base()->Begin() );
WCVector4 p1( this->_line->Base()->End() );
this->_length = p0.Distance(p1);
//Check feature name
if (this->_name == "") this->_name = this->_sketch->GenerateFeatureName(this);
this->_color = WCSketchFeature::ConstraintColor;
//Remaining initialization
this->Initialize();
}
WCConstraintLength::WCConstraintLength(xercesc::DOMElement *element, WCSerialDictionary *dictionary) :
::WCSketchConstraint( WCSerializeableObject::ElementFromName(element,"SketchConstraint"), dictionary ),
_line(NULL), _length(0.0), _measure(NULL) {
//Make sure element if not null
if (element == NULL) return;
//Get GUID and register it
WCGUID guid = WCSerializeableObject::GetStringAttrib(element, "guid");
dictionary->InsertGUID(guid, this);
//Recreate the line
this->_line = (WCSketchLine*)WCSerializeableObject::GetGUIDAttrib(element, "line", dictionary);
//Setup length
this->_length = WCSerializeableObject::GetFloatAttrib(element, "length");
//Remaining initialization
this->Initialize();
}
WCConstraintLength::~WCConstraintLength() {
//Release the line
this->_line->Release(*this);
//Remove from the sketch
if (!this->_sketch->RemoveConstraint(this)) {
CLOGGER_ERROR(WCLogManager::RootLogger(), "WCConstraintLength::~WCConstraintLength - Problem removing constraint from sketch.");
}
//Check to see if old measure needs to be deleted
if (this->_measure != NULL) delete this->_measure;
}
void WCConstraintLength::InjectConstraints(WCConstraintPlanner *planner) {
//Get the list of constraint nodes from the line
std::list<WCConstraintNode*> nodeList = this->_line->ConstraintNodes();
//Make sure there are three nodes
if (nodeList.size() != 3) {
CLOGGER_ERROR(WCLogManager::RootLogger(), "WCConstraintLength::InjectConstraints - Not three nodes in line's list.");
return;
}
std::list<WCConstraintNode*>::iterator iter = nodeList.begin();
//Get the starting point (second node in list) and ending point (third node in list) of the line
iter++;
WCConstraintNode *p0Node = *iter++;
WCConstraintNode *p1Node = *iter;
//Add a constraint edge to the planner
planner->AddEdge(this, p0Node, p1Node, WCConstraintEdgeType::AbsoluteDistance(), 1, WCVector4(0.0));
}
void WCConstraintLength::ReceiveNotice(WCObjectMsg msg, WCObject *sender) {
//Determine values for measure
WCVector4 p0( this->_line->Base()->Begin() );
WCVector4 p1( this->_line->Base()->End() );
//Calcuate length of line
this->_length = p0.Distance(p1);
//Set the measure label
std::string label = this->_line->Document()->LengthUnit()->DisplayString(this->_length, 4);
this->_measure->Text()->Text(label);
//Set the measure position
this->_measure->Points(p0, p1);
}
bool WCConstraintLength::Regenerate(void) {
return false;
}
std::list<WCObject*> WCConstraintLength::DeletionDependencies(void) {
return std::list<WCObject*>();
}
void WCConstraintLength::OnSelection(const bool fromManager, std::list<WCVisualObject*> objects) {
//Set the color
this->_color.Set(WCSketchFeature::SelectedColor);
this->_measure->Text()->Color(WCSketchFeature::SelectedColor);
//Mark this as selected
this->_isSelected = true;
}
void WCConstraintLength::OnDeselection(const bool fromManager) {
//Set the color
this->_color.Set(WCSketchFeature::ConstraintColor);
this->_measure->Text()->Color(WCSketchFeature::DefaultTextColor);
//Mark this as not selected
this->_isSelected = false;
}
void WCConstraintLength::Render(const GLuint &defaultProg, const WCColor &color, const WPFloat &zoom) {
//Make sure is visible
if (!this->_isVisible) return;
//Check the color (see if in selection mode)
if (color == WCColor::Default()) {
//Just call measure to render
this->_measure->Render(this->_color);
}
//Not in selection mode
else {
//Call measure to render for selection
this->_measure->Render(color, true);
}
}
xercesc::DOMElement* WCConstraintLength::Serialize(xercesc::DOMDocument *document, WCSerialDictionary *dictionary) {
//Insert self into dictionary
WCGUID guid = dictionary->InsertAddress(this);
//Create primary element for this object
XMLCh* xmlString = xercesc::XMLString::transcode("ConstraintLength");
xercesc::DOMElement* element = document->createElement(xmlString);
xercesc::XMLString::release(&xmlString);
//Include the parent element
xercesc::DOMElement* featureElement = this->WCSketchConstraint::Serialize(document, dictionary);
element->appendChild(featureElement);
//Add GUID attribute
WCSerializeableObject::AddStringAttrib(element, "guid", guid);
dictionary->InsertGUID(guid, this);
//Add length attribute
WCSerializeableObject::AddFloatAttrib(element, "length", this->_length);
//Add line attribute
WCSerializeableObject::AddGUIDAttrib(element, "line", this->_line, dictionary);
//Return the new element
return element;
}
/***********************************************~***************************************************/
WCDrawingMode* WCConstraintLength::ModeEdit(WCConstraintLength *constraint) {
//Create a new editing mode
return new WCModeConstraintLengthEdit(constraint);
}
WCActionConstraintLengthCreate* WCConstraintLength::ActionCreate(WCSketch *sketch, const std::string &constraintName, WCSketchLine *line) {
//Create new action to create constraint
return new WCActionConstraintLengthCreate(sketch, constraintName, line);
}
WCActionConstraintLengthMove* WCConstraintLength::ActionMove(WCConstraintLength *constraint, const WPFloat &offset, const WPFloat &labelOffset) {
//Create new action to move the constraint
return new WCActionConstraintLengthMove(constraint, offset, labelOffset);
}
/***********************************************~***************************************************/
std::ostream& operator<<(std::ostream& out, const WCConstraintLength &constraint) {
std::cout << "Constraint Length(" << &constraint << ")\n";
return out;
}
/***********************************************~***************************************************/
| 38.594796 | 145 | 0.704103 | neonkingfr |
b38ccf128d443e4068965a90fc79f744eb360371 | 1,409 | cpp | C++ | src/contract/Data.cpp | pestotoast/mmx-node | eb9e27aa077c111e814c62cc5b716c4957eac09e | [
"Apache-2.0"
] | 2 | 2022-01-12T02:00:10.000Z | 2022-02-05T03:59:43.000Z | src/contract/Data.cpp | pestotoast/mmx-node | eb9e27aa077c111e814c62cc5b716c4957eac09e | [
"Apache-2.0"
] | null | null | null | src/contract/Data.cpp | pestotoast/mmx-node | eb9e27aa077c111e814c62cc5b716c4957eac09e | [
"Apache-2.0"
] | null | null | null | /*
* Data.cpp
*
* Created on: Jan 19, 2022
* Author: mad
*/
#include <mmx/contract/Data.hxx>
#include <mmx/write_bytes.h>
namespace mmx {
namespace contract {
hash_t Data::calc_hash() const
{
std::vector<uint8_t> buffer;
vnx::VectorOutputStream stream(&buffer);
vnx::OutputBuffer out(&stream);
write_bytes(out, get_type_hash());
write_bytes(out, version);
write_bytes(out, owner);
write_bytes(out, value);
out.flush();
return hash_t(buffer);
}
uint64_t Data::calc_cost(std::shared_ptr<const ChainParams> params) const {
return (8 + 4 + (owner ? 32 : 0) + value.size()) * params->min_txfee_byte;
}
std::vector<addr_t> Data::get_dependency() const {
if(owner) {
return {*owner};
}
return {};
}
std::vector<addr_t> Data::get_parties() const {
return get_dependency();
}
vnx::optional<addr_t> Data::get_owner() const {
return owner;
}
std::vector<tx_out_t> Data::validate(std::shared_ptr<const Operation> operation, std::shared_ptr<const Context> context) const
{
if(!owner) {
throw std::logic_error("!owner");
}
{
auto contract = context->get_contract(*owner);
if(!contract) {
throw std::logic_error("missing dependency");
}
contract->validate(operation, context);
}
return {};
}
void Data::transfer(const vnx::optional<addr_t>& new_owner)
{
owner = new_owner;
}
void Data::set(const vnx::Variant& value_)
{
value = value_;
}
} // contract
} // mmx
| 18.298701 | 126 | 0.682754 | pestotoast |
b38f32236bf0a3cece67f7e108e6e7721cff7281 | 132,716 | cc | C++ | libgav1/src/dsp/x86/loop_restoration_10bit_avx2.cc | P-404/android_external_libgav1 | 4e6f3403a267fc31f9a6fa85683f824fb8b15bd8 | [
"Apache-2.0"
] | null | null | null | libgav1/src/dsp/x86/loop_restoration_10bit_avx2.cc | P-404/android_external_libgav1 | 4e6f3403a267fc31f9a6fa85683f824fb8b15bd8 | [
"Apache-2.0"
] | null | null | null | libgav1/src/dsp/x86/loop_restoration_10bit_avx2.cc | P-404/android_external_libgav1 | 4e6f3403a267fc31f9a6fa85683f824fb8b15bd8 | [
"Apache-2.0"
] | null | null | null | // Copyright 2020 The libgav1 Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/dsp/loop_restoration.h"
#include "src/utils/cpu.h"
#if LIBGAV1_TARGETING_AVX2 && LIBGAV1_MAX_BITDEPTH >= 10
#include <immintrin.h>
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include "src/dsp/common.h"
#include "src/dsp/constants.h"
#include "src/dsp/dsp.h"
#include "src/dsp/x86/common_avx2.h"
#include "src/utils/common.h"
#include "src/utils/constants.h"
namespace libgav1 {
namespace dsp {
namespace {
inline void WienerHorizontalClip(const __m256i s[2],
int16_t* const wiener_buffer) {
constexpr int offset =
1 << (10 + kWienerFilterBits - kInterRoundBitsHorizontal - 1);
constexpr int limit = (offset << 2) - 1;
const __m256i offsets = _mm256_set1_epi16(-offset);
const __m256i limits = _mm256_set1_epi16(limit - offset);
const __m256i round = _mm256_set1_epi32(1 << (kInterRoundBitsHorizontal - 1));
const __m256i sum0 = _mm256_add_epi32(s[0], round);
const __m256i sum1 = _mm256_add_epi32(s[1], round);
const __m256i rounded_sum0 =
_mm256_srai_epi32(sum0, kInterRoundBitsHorizontal);
const __m256i rounded_sum1 =
_mm256_srai_epi32(sum1, kInterRoundBitsHorizontal);
const __m256i rounded_sum = _mm256_packs_epi32(rounded_sum0, rounded_sum1);
const __m256i d0 = _mm256_max_epi16(rounded_sum, offsets);
const __m256i d1 = _mm256_min_epi16(d0, limits);
StoreAligned32(wiener_buffer, d1);
}
inline void WienerHorizontalTap7Kernel(const __m256i s[7],
const __m256i filter[2],
int16_t* const wiener_buffer) {
const __m256i s06 = _mm256_add_epi16(s[0], s[6]);
const __m256i s15 = _mm256_add_epi16(s[1], s[5]);
const __m256i s24 = _mm256_add_epi16(s[2], s[4]);
const __m256i ss0 = _mm256_unpacklo_epi16(s06, s15);
const __m256i ss1 = _mm256_unpackhi_epi16(s06, s15);
const __m256i ss2 = _mm256_unpacklo_epi16(s24, s[3]);
const __m256i ss3 = _mm256_unpackhi_epi16(s24, s[3]);
__m256i madds[4];
madds[0] = _mm256_madd_epi16(ss0, filter[0]);
madds[1] = _mm256_madd_epi16(ss1, filter[0]);
madds[2] = _mm256_madd_epi16(ss2, filter[1]);
madds[3] = _mm256_madd_epi16(ss3, filter[1]);
madds[0] = _mm256_add_epi32(madds[0], madds[2]);
madds[1] = _mm256_add_epi32(madds[1], madds[3]);
WienerHorizontalClip(madds, wiener_buffer);
}
inline void WienerHorizontalTap5Kernel(const __m256i s[5], const __m256i filter,
int16_t* const wiener_buffer) {
const __m256i s04 = _mm256_add_epi16(s[0], s[4]);
const __m256i s13 = _mm256_add_epi16(s[1], s[3]);
const __m256i s2d = _mm256_add_epi16(s[2], s[2]);
const __m256i s0m = _mm256_sub_epi16(s04, s2d);
const __m256i s1m = _mm256_sub_epi16(s13, s2d);
const __m256i ss0 = _mm256_unpacklo_epi16(s0m, s1m);
const __m256i ss1 = _mm256_unpackhi_epi16(s0m, s1m);
__m256i madds[2];
madds[0] = _mm256_madd_epi16(ss0, filter);
madds[1] = _mm256_madd_epi16(ss1, filter);
const __m256i s2_lo = _mm256_unpacklo_epi16(s[2], _mm256_setzero_si256());
const __m256i s2_hi = _mm256_unpackhi_epi16(s[2], _mm256_setzero_si256());
const __m256i s2x128_lo = _mm256_slli_epi32(s2_lo, 7);
const __m256i s2x128_hi = _mm256_slli_epi32(s2_hi, 7);
madds[0] = _mm256_add_epi32(madds[0], s2x128_lo);
madds[1] = _mm256_add_epi32(madds[1], s2x128_hi);
WienerHorizontalClip(madds, wiener_buffer);
}
inline void WienerHorizontalTap3Kernel(const __m256i s[3], const __m256i filter,
int16_t* const wiener_buffer) {
const __m256i s02 = _mm256_add_epi16(s[0], s[2]);
const __m256i ss0 = _mm256_unpacklo_epi16(s02, s[1]);
const __m256i ss1 = _mm256_unpackhi_epi16(s02, s[1]);
__m256i madds[2];
madds[0] = _mm256_madd_epi16(ss0, filter);
madds[1] = _mm256_madd_epi16(ss1, filter);
WienerHorizontalClip(madds, wiener_buffer);
}
inline void WienerHorizontalTap7(const uint16_t* src,
const ptrdiff_t src_stride,
const ptrdiff_t width, const int height,
const __m256i* const coefficients,
int16_t** const wiener_buffer) {
__m256i filter[2];
filter[0] = _mm256_shuffle_epi32(*coefficients, 0x0);
filter[1] = _mm256_shuffle_epi32(*coefficients, 0x55);
for (int y = height; y != 0; --y) {
ptrdiff_t x = 0;
do {
__m256i s[7];
s[0] = LoadUnaligned32(src + x + 0);
s[1] = LoadUnaligned32(src + x + 1);
s[2] = LoadUnaligned32(src + x + 2);
s[3] = LoadUnaligned32(src + x + 3);
s[4] = LoadUnaligned32(src + x + 4);
s[5] = LoadUnaligned32(src + x + 5);
s[6] = LoadUnaligned32(src + x + 6);
WienerHorizontalTap7Kernel(s, filter, *wiener_buffer + x);
x += 16;
} while (x < width);
src += src_stride;
*wiener_buffer += width;
}
}
inline void WienerHorizontalTap5(const uint16_t* src,
const ptrdiff_t src_stride,
const ptrdiff_t width, const int height,
const __m256i* const coefficients,
int16_t** const wiener_buffer) {
const __m256i filter =
_mm256_shuffle_epi8(*coefficients, _mm256_set1_epi32(0x05040302));
for (int y = height; y != 0; --y) {
ptrdiff_t x = 0;
do {
__m256i s[5];
s[0] = LoadUnaligned32(src + x + 0);
s[1] = LoadUnaligned32(src + x + 1);
s[2] = LoadUnaligned32(src + x + 2);
s[3] = LoadUnaligned32(src + x + 3);
s[4] = LoadUnaligned32(src + x + 4);
WienerHorizontalTap5Kernel(s, filter, *wiener_buffer + x);
x += 16;
} while (x < width);
src += src_stride;
*wiener_buffer += width;
}
}
inline void WienerHorizontalTap3(const uint16_t* src,
const ptrdiff_t src_stride,
const ptrdiff_t width, const int height,
const __m256i* const coefficients,
int16_t** const wiener_buffer) {
const auto filter = _mm256_shuffle_epi32(*coefficients, 0x55);
for (int y = height; y != 0; --y) {
ptrdiff_t x = 0;
do {
__m256i s[3];
s[0] = LoadUnaligned32(src + x + 0);
s[1] = LoadUnaligned32(src + x + 1);
s[2] = LoadUnaligned32(src + x + 2);
WienerHorizontalTap3Kernel(s, filter, *wiener_buffer + x);
x += 16;
} while (x < width);
src += src_stride;
*wiener_buffer += width;
}
}
inline void WienerHorizontalTap1(const uint16_t* src,
const ptrdiff_t src_stride,
const ptrdiff_t width, const int height,
int16_t** const wiener_buffer) {
for (int y = height; y != 0; --y) {
ptrdiff_t x = 0;
do {
const __m256i s0 = LoadUnaligned32(src + x);
const __m256i d0 = _mm256_slli_epi16(s0, 4);
StoreAligned32(*wiener_buffer + x, d0);
x += 16;
} while (x < width);
src += src_stride;
*wiener_buffer += width;
}
}
inline __m256i WienerVertical7(const __m256i a[4], const __m256i filter[4]) {
const __m256i madd0 = _mm256_madd_epi16(a[0], filter[0]);
const __m256i madd1 = _mm256_madd_epi16(a[1], filter[1]);
const __m256i madd2 = _mm256_madd_epi16(a[2], filter[2]);
const __m256i madd3 = _mm256_madd_epi16(a[3], filter[3]);
const __m256i madd01 = _mm256_add_epi32(madd0, madd1);
const __m256i madd23 = _mm256_add_epi32(madd2, madd3);
const __m256i sum = _mm256_add_epi32(madd01, madd23);
return _mm256_srai_epi32(sum, kInterRoundBitsVertical);
}
inline __m256i WienerVertical5(const __m256i a[3], const __m256i filter[3]) {
const __m256i madd0 = _mm256_madd_epi16(a[0], filter[0]);
const __m256i madd1 = _mm256_madd_epi16(a[1], filter[1]);
const __m256i madd2 = _mm256_madd_epi16(a[2], filter[2]);
const __m256i madd01 = _mm256_add_epi32(madd0, madd1);
const __m256i sum = _mm256_add_epi32(madd01, madd2);
return _mm256_srai_epi32(sum, kInterRoundBitsVertical);
}
inline __m256i WienerVertical3(const __m256i a[2], const __m256i filter[2]) {
const __m256i madd0 = _mm256_madd_epi16(a[0], filter[0]);
const __m256i madd1 = _mm256_madd_epi16(a[1], filter[1]);
const __m256i sum = _mm256_add_epi32(madd0, madd1);
return _mm256_srai_epi32(sum, kInterRoundBitsVertical);
}
inline __m256i WienerVerticalClip(const __m256i s[2]) {
const __m256i d = _mm256_packus_epi32(s[0], s[1]);
return _mm256_min_epu16(d, _mm256_set1_epi16(1023));
}
inline __m256i WienerVerticalFilter7(const __m256i a[7],
const __m256i filter[2]) {
const __m256i round = _mm256_set1_epi16(1 << (kInterRoundBitsVertical - 1));
__m256i b[4], c[2];
b[0] = _mm256_unpacklo_epi16(a[0], a[1]);
b[1] = _mm256_unpacklo_epi16(a[2], a[3]);
b[2] = _mm256_unpacklo_epi16(a[4], a[5]);
b[3] = _mm256_unpacklo_epi16(a[6], round);
c[0] = WienerVertical7(b, filter);
b[0] = _mm256_unpackhi_epi16(a[0], a[1]);
b[1] = _mm256_unpackhi_epi16(a[2], a[3]);
b[2] = _mm256_unpackhi_epi16(a[4], a[5]);
b[3] = _mm256_unpackhi_epi16(a[6], round);
c[1] = WienerVertical7(b, filter);
return WienerVerticalClip(c);
}
inline __m256i WienerVerticalFilter5(const __m256i a[5],
const __m256i filter[3]) {
const __m256i round = _mm256_set1_epi16(1 << (kInterRoundBitsVertical - 1));
__m256i b[3], c[2];
b[0] = _mm256_unpacklo_epi16(a[0], a[1]);
b[1] = _mm256_unpacklo_epi16(a[2], a[3]);
b[2] = _mm256_unpacklo_epi16(a[4], round);
c[0] = WienerVertical5(b, filter);
b[0] = _mm256_unpackhi_epi16(a[0], a[1]);
b[1] = _mm256_unpackhi_epi16(a[2], a[3]);
b[2] = _mm256_unpackhi_epi16(a[4], round);
c[1] = WienerVertical5(b, filter);
return WienerVerticalClip(c);
}
inline __m256i WienerVerticalFilter3(const __m256i a[3],
const __m256i filter[2]) {
const __m256i round = _mm256_set1_epi16(1 << (kInterRoundBitsVertical - 1));
__m256i b[2], c[2];
b[0] = _mm256_unpacklo_epi16(a[0], a[1]);
b[1] = _mm256_unpacklo_epi16(a[2], round);
c[0] = WienerVertical3(b, filter);
b[0] = _mm256_unpackhi_epi16(a[0], a[1]);
b[1] = _mm256_unpackhi_epi16(a[2], round);
c[1] = WienerVertical3(b, filter);
return WienerVerticalClip(c);
}
inline __m256i WienerVerticalTap7Kernel(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[2], __m256i a[7]) {
a[0] = LoadAligned32(wiener_buffer + 0 * wiener_stride);
a[1] = LoadAligned32(wiener_buffer + 1 * wiener_stride);
a[2] = LoadAligned32(wiener_buffer + 2 * wiener_stride);
a[3] = LoadAligned32(wiener_buffer + 3 * wiener_stride);
a[4] = LoadAligned32(wiener_buffer + 4 * wiener_stride);
a[5] = LoadAligned32(wiener_buffer + 5 * wiener_stride);
a[6] = LoadAligned32(wiener_buffer + 6 * wiener_stride);
return WienerVerticalFilter7(a, filter);
}
inline __m256i WienerVerticalTap5Kernel(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[3], __m256i a[5]) {
a[0] = LoadAligned32(wiener_buffer + 0 * wiener_stride);
a[1] = LoadAligned32(wiener_buffer + 1 * wiener_stride);
a[2] = LoadAligned32(wiener_buffer + 2 * wiener_stride);
a[3] = LoadAligned32(wiener_buffer + 3 * wiener_stride);
a[4] = LoadAligned32(wiener_buffer + 4 * wiener_stride);
return WienerVerticalFilter5(a, filter);
}
inline __m256i WienerVerticalTap3Kernel(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[2], __m256i a[3]) {
a[0] = LoadAligned32(wiener_buffer + 0 * wiener_stride);
a[1] = LoadAligned32(wiener_buffer + 1 * wiener_stride);
a[2] = LoadAligned32(wiener_buffer + 2 * wiener_stride);
return WienerVerticalFilter3(a, filter);
}
inline void WienerVerticalTap7Kernel2(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[2], __m256i d[2]) {
__m256i a[8];
d[0] = WienerVerticalTap7Kernel(wiener_buffer, wiener_stride, filter, a);
a[7] = LoadAligned32(wiener_buffer + 7 * wiener_stride);
d[1] = WienerVerticalFilter7(a + 1, filter);
}
inline void WienerVerticalTap5Kernel2(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[3], __m256i d[2]) {
__m256i a[6];
d[0] = WienerVerticalTap5Kernel(wiener_buffer, wiener_stride, filter, a);
a[5] = LoadAligned32(wiener_buffer + 5 * wiener_stride);
d[1] = WienerVerticalFilter5(a + 1, filter);
}
inline void WienerVerticalTap3Kernel2(const int16_t* wiener_buffer,
const ptrdiff_t wiener_stride,
const __m256i filter[2], __m256i d[2]) {
__m256i a[4];
d[0] = WienerVerticalTap3Kernel(wiener_buffer, wiener_stride, filter, a);
a[3] = LoadAligned32(wiener_buffer + 3 * wiener_stride);
d[1] = WienerVerticalFilter3(a + 1, filter);
}
inline void WienerVerticalTap7(const int16_t* wiener_buffer,
const ptrdiff_t width, const int height,
const int16_t coefficients[4], uint16_t* dst,
const ptrdiff_t dst_stride) {
const __m256i c = _mm256_broadcastq_epi64(LoadLo8(coefficients));
__m256i filter[4];
filter[0] = _mm256_shuffle_epi32(c, 0x0);
filter[1] = _mm256_shuffle_epi32(c, 0x55);
filter[2] = _mm256_shuffle_epi8(c, _mm256_set1_epi32(0x03020504));
filter[3] =
_mm256_set1_epi32((1 << 16) | static_cast<uint16_t>(coefficients[0]));
for (int y = height >> 1; y > 0; --y) {
ptrdiff_t x = 0;
do {
__m256i d[2];
WienerVerticalTap7Kernel2(wiener_buffer + x, width, filter, d);
StoreUnaligned32(dst + x, d[0]);
StoreUnaligned32(dst + dst_stride + x, d[1]);
x += 16;
} while (x < width);
dst += 2 * dst_stride;
wiener_buffer += 2 * width;
}
if ((height & 1) != 0) {
ptrdiff_t x = 0;
do {
__m256i a[7];
const __m256i d =
WienerVerticalTap7Kernel(wiener_buffer + x, width, filter, a);
StoreUnaligned32(dst + x, d);
x += 16;
} while (x < width);
}
}
inline void WienerVerticalTap5(const int16_t* wiener_buffer,
const ptrdiff_t width, const int height,
const int16_t coefficients[3], uint16_t* dst,
const ptrdiff_t dst_stride) {
const __m256i c = _mm256_broadcastq_epi64(LoadLo8(coefficients));
__m256i filter[3];
filter[0] = _mm256_shuffle_epi32(c, 0x0);
filter[1] = _mm256_shuffle_epi8(c, _mm256_set1_epi32(0x03020504));
filter[2] =
_mm256_set1_epi32((1 << 16) | static_cast<uint16_t>(coefficients[0]));
for (int y = height >> 1; y > 0; --y) {
ptrdiff_t x = 0;
do {
__m256i d[2];
WienerVerticalTap5Kernel2(wiener_buffer + x, width, filter, d);
StoreUnaligned32(dst + x, d[0]);
StoreUnaligned32(dst + dst_stride + x, d[1]);
x += 16;
} while (x < width);
dst += 2 * dst_stride;
wiener_buffer += 2 * width;
}
if ((height & 1) != 0) {
ptrdiff_t x = 0;
do {
__m256i a[5];
const __m256i d =
WienerVerticalTap5Kernel(wiener_buffer + x, width, filter, a);
StoreUnaligned32(dst + x, d);
x += 16;
} while (x < width);
}
}
inline void WienerVerticalTap3(const int16_t* wiener_buffer,
const ptrdiff_t width, const int height,
const int16_t coefficients[2], uint16_t* dst,
const ptrdiff_t dst_stride) {
__m256i filter[2];
filter[0] =
_mm256_set1_epi32(*reinterpret_cast<const int32_t*>(coefficients));
filter[1] =
_mm256_set1_epi32((1 << 16) | static_cast<uint16_t>(coefficients[0]));
for (int y = height >> 1; y > 0; --y) {
ptrdiff_t x = 0;
do {
__m256i d[2][2];
WienerVerticalTap3Kernel2(wiener_buffer + x, width, filter, d[0]);
StoreUnaligned32(dst + x, d[0][0]);
StoreUnaligned32(dst + dst_stride + x, d[0][1]);
x += 16;
} while (x < width);
dst += 2 * dst_stride;
wiener_buffer += 2 * width;
}
if ((height & 1) != 0) {
ptrdiff_t x = 0;
do {
__m256i a[3];
const __m256i d =
WienerVerticalTap3Kernel(wiener_buffer + x, width, filter, a);
StoreUnaligned32(dst + x, d);
x += 16;
} while (x < width);
}
}
inline void WienerVerticalTap1Kernel(const int16_t* const wiener_buffer,
uint16_t* const dst) {
const __m256i a = LoadAligned32(wiener_buffer);
const __m256i b = _mm256_add_epi16(a, _mm256_set1_epi16(8));
const __m256i c = _mm256_srai_epi16(b, 4);
const __m256i d = _mm256_max_epi16(c, _mm256_setzero_si256());
const __m256i e = _mm256_min_epi16(d, _mm256_set1_epi16(1023));
StoreUnaligned32(dst, e);
}
inline void WienerVerticalTap1(const int16_t* wiener_buffer,
const ptrdiff_t width, const int height,
uint16_t* dst, const ptrdiff_t dst_stride) {
for (int y = height >> 1; y > 0; --y) {
ptrdiff_t x = 0;
do {
WienerVerticalTap1Kernel(wiener_buffer + x, dst + x);
WienerVerticalTap1Kernel(wiener_buffer + width + x, dst + dst_stride + x);
x += 16;
} while (x < width);
dst += 2 * dst_stride;
wiener_buffer += 2 * width;
}
if ((height & 1) != 0) {
ptrdiff_t x = 0;
do {
WienerVerticalTap1Kernel(wiener_buffer + x, dst + x);
x += 16;
} while (x < width);
}
}
void WienerFilter_AVX2(
const RestorationUnitInfo& restoration_info, const void* const source,
const ptrdiff_t stride, const void* const top_border,
const ptrdiff_t top_border_stride, const void* const bottom_border,
const ptrdiff_t bottom_border_stride, const int width, const int height,
RestorationBuffer* const restoration_buffer, void* const dest) {
const int16_t* const number_leading_zero_coefficients =
restoration_info.wiener_info.number_leading_zero_coefficients;
const int number_rows_to_skip = std::max(
static_cast<int>(number_leading_zero_coefficients[WienerInfo::kVertical]),
1);
const ptrdiff_t wiener_stride = Align(width, 16);
int16_t* const wiener_buffer_vertical = restoration_buffer->wiener_buffer;
// The values are saturated to 13 bits before storing.
int16_t* wiener_buffer_horizontal =
wiener_buffer_vertical + number_rows_to_skip * wiener_stride;
// horizontal filtering.
// Over-reads up to 15 - |kRestorationHorizontalBorder| values.
const int height_horizontal =
height + kWienerFilterTaps - 1 - 2 * number_rows_to_skip;
const int height_extra = (height_horizontal - height) >> 1;
assert(height_extra <= 2);
const auto* const src = static_cast<const uint16_t*>(source);
const auto* const top = static_cast<const uint16_t*>(top_border);
const auto* const bottom = static_cast<const uint16_t*>(bottom_border);
const __m128i c =
LoadLo8(restoration_info.wiener_info.filter[WienerInfo::kHorizontal]);
const __m256i coefficients_horizontal = _mm256_broadcastq_epi64(c);
if (number_leading_zero_coefficients[WienerInfo::kHorizontal] == 0) {
WienerHorizontalTap7(top + (2 - height_extra) * top_border_stride - 3,
top_border_stride, wiener_stride, height_extra,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap7(src - 3, stride, wiener_stride, height,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap7(bottom - 3, bottom_border_stride, wiener_stride,
height_extra, &coefficients_horizontal,
&wiener_buffer_horizontal);
} else if (number_leading_zero_coefficients[WienerInfo::kHorizontal] == 1) {
WienerHorizontalTap5(top + (2 - height_extra) * top_border_stride - 2,
top_border_stride, wiener_stride, height_extra,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap5(src - 2, stride, wiener_stride, height,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap5(bottom - 2, bottom_border_stride, wiener_stride,
height_extra, &coefficients_horizontal,
&wiener_buffer_horizontal);
} else if (number_leading_zero_coefficients[WienerInfo::kHorizontal] == 2) {
// The maximum over-reads happen here.
WienerHorizontalTap3(top + (2 - height_extra) * top_border_stride - 1,
top_border_stride, wiener_stride, height_extra,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap3(src - 1, stride, wiener_stride, height,
&coefficients_horizontal, &wiener_buffer_horizontal);
WienerHorizontalTap3(bottom - 1, bottom_border_stride, wiener_stride,
height_extra, &coefficients_horizontal,
&wiener_buffer_horizontal);
} else {
assert(number_leading_zero_coefficients[WienerInfo::kHorizontal] == 3);
WienerHorizontalTap1(top + (2 - height_extra) * top_border_stride,
top_border_stride, wiener_stride, height_extra,
&wiener_buffer_horizontal);
WienerHorizontalTap1(src, stride, wiener_stride, height,
&wiener_buffer_horizontal);
WienerHorizontalTap1(bottom, bottom_border_stride, wiener_stride,
height_extra, &wiener_buffer_horizontal);
}
// vertical filtering.
// Over-writes up to 15 values.
const int16_t* const filter_vertical =
restoration_info.wiener_info.filter[WienerInfo::kVertical];
auto* dst = static_cast<uint16_t*>(dest);
if (number_leading_zero_coefficients[WienerInfo::kVertical] == 0) {
// Because the top row of |source| is a duplicate of the second row, and the
// bottom row of |source| is a duplicate of its above row, we can duplicate
// the top and bottom row of |wiener_buffer| accordingly.
memcpy(wiener_buffer_horizontal, wiener_buffer_horizontal - wiener_stride,
sizeof(*wiener_buffer_horizontal) * wiener_stride);
memcpy(restoration_buffer->wiener_buffer,
restoration_buffer->wiener_buffer + wiener_stride,
sizeof(*restoration_buffer->wiener_buffer) * wiener_stride);
WienerVerticalTap7(wiener_buffer_vertical, wiener_stride, height,
filter_vertical, dst, stride);
} else if (number_leading_zero_coefficients[WienerInfo::kVertical] == 1) {
WienerVerticalTap5(wiener_buffer_vertical + wiener_stride, wiener_stride,
height, filter_vertical + 1, dst, stride);
} else if (number_leading_zero_coefficients[WienerInfo::kVertical] == 2) {
WienerVerticalTap3(wiener_buffer_vertical + 2 * wiener_stride,
wiener_stride, height, filter_vertical + 2, dst, stride);
} else {
assert(number_leading_zero_coefficients[WienerInfo::kVertical] == 3);
WienerVerticalTap1(wiener_buffer_vertical + 3 * wiener_stride,
wiener_stride, height, dst, stride);
}
}
//------------------------------------------------------------------------------
// SGR
constexpr int kSumOffset = 24;
// SIMD overreads the number of pixels in SIMD registers - (width % 8) - 2 *
// padding pixels, where padding is 3 for Pass 1 and 2 for Pass 2. The number of
// bytes in SIMD registers is 16 for SSE4.1 and 32 for AVX2.
constexpr int kOverreadInBytesPass1_128 = 4;
constexpr int kOverreadInBytesPass2_128 = 8;
constexpr int kOverreadInBytesPass1_256 = kOverreadInBytesPass1_128 + 16;
constexpr int kOverreadInBytesPass2_256 = kOverreadInBytesPass2_128 + 16;
inline void LoadAligned16x2U16(const uint16_t* const src[2], const ptrdiff_t x,
__m128i dst[2]) {
dst[0] = LoadAligned16(src[0] + x);
dst[1] = LoadAligned16(src[1] + x);
}
inline void LoadAligned32x2U16(const uint16_t* const src[2], const ptrdiff_t x,
__m256i dst[2]) {
dst[0] = LoadAligned32(src[0] + x);
dst[1] = LoadAligned32(src[1] + x);
}
inline void LoadAligned32x2U16Msan(const uint16_t* const src[2],
const ptrdiff_t x, const ptrdiff_t border,
__m256i dst[2]) {
dst[0] = LoadAligned32Msan(src[0] + x, sizeof(**src) * (x + 16 - border));
dst[1] = LoadAligned32Msan(src[1] + x, sizeof(**src) * (x + 16 - border));
}
inline void LoadAligned16x3U16(const uint16_t* const src[3], const ptrdiff_t x,
__m128i dst[3]) {
dst[0] = LoadAligned16(src[0] + x);
dst[1] = LoadAligned16(src[1] + x);
dst[2] = LoadAligned16(src[2] + x);
}
inline void LoadAligned32x3U16(const uint16_t* const src[3], const ptrdiff_t x,
__m256i dst[3]) {
dst[0] = LoadAligned32(src[0] + x);
dst[1] = LoadAligned32(src[1] + x);
dst[2] = LoadAligned32(src[2] + x);
}
inline void LoadAligned32x3U16Msan(const uint16_t* const src[3],
const ptrdiff_t x, const ptrdiff_t border,
__m256i dst[3]) {
dst[0] = LoadAligned32Msan(src[0] + x, sizeof(**src) * (x + 16 - border));
dst[1] = LoadAligned32Msan(src[1] + x, sizeof(**src) * (x + 16 - border));
dst[2] = LoadAligned32Msan(src[2] + x, sizeof(**src) * (x + 16 - border));
}
inline void LoadAligned32U32(const uint32_t* const src, __m128i dst[2]) {
dst[0] = LoadAligned16(src + 0);
dst[1] = LoadAligned16(src + 4);
}
inline void LoadAligned32x2U32(const uint32_t* const src[2], const ptrdiff_t x,
__m128i dst[2][2]) {
LoadAligned32U32(src[0] + x, dst[0]);
LoadAligned32U32(src[1] + x, dst[1]);
}
inline void LoadAligned64x2U32(const uint32_t* const src[2], const ptrdiff_t x,
__m256i dst[2][2]) {
LoadAligned64(src[0] + x, dst[0]);
LoadAligned64(src[1] + x, dst[1]);
}
inline void LoadAligned64x2U32Msan(const uint32_t* const src[2],
const ptrdiff_t x, const ptrdiff_t border,
__m256i dst[2][2]) {
LoadAligned64Msan(src[0] + x, sizeof(**src) * (x + 16 - border), dst[0]);
LoadAligned64Msan(src[1] + x, sizeof(**src) * (x + 16 - border), dst[1]);
}
inline void LoadAligned32x3U32(const uint32_t* const src[3], const ptrdiff_t x,
__m128i dst[3][2]) {
LoadAligned32U32(src[0] + x, dst[0]);
LoadAligned32U32(src[1] + x, dst[1]);
LoadAligned32U32(src[2] + x, dst[2]);
}
inline void LoadAligned64x3U32(const uint32_t* const src[3], const ptrdiff_t x,
__m256i dst[3][2]) {
LoadAligned64(src[0] + x, dst[0]);
LoadAligned64(src[1] + x, dst[1]);
LoadAligned64(src[2] + x, dst[2]);
}
inline void LoadAligned64x3U32Msan(const uint32_t* const src[3],
const ptrdiff_t x, const ptrdiff_t border,
__m256i dst[3][2]) {
LoadAligned64Msan(src[0] + x, sizeof(**src) * (x + 16 - border), dst[0]);
LoadAligned64Msan(src[1] + x, sizeof(**src) * (x + 16 - border), dst[1]);
LoadAligned64Msan(src[2] + x, sizeof(**src) * (x + 16 - border), dst[2]);
}
inline void StoreAligned32U32(uint32_t* const dst, const __m128i src[2]) {
StoreAligned16(dst + 0, src[0]);
StoreAligned16(dst + 4, src[1]);
}
// The AVX2 ymm register holds ma[0], ma[1], ..., ma[7], and ma[16], ma[17],
// ..., ma[23].
// There is an 8 pixel gap between the first half and the second half.
constexpr int kMaStoreOffset = 8;
inline void StoreAligned32_ma(uint16_t* src, const __m256i v) {
StoreAligned16(src + 0 * 8, _mm256_extracti128_si256(v, 0));
StoreAligned16(src + 2 * 8, _mm256_extracti128_si256(v, 1));
}
inline void StoreAligned64_ma(uint16_t* src, const __m256i v[2]) {
// The next 4 lines are much faster than:
// StoreAligned32(src + 0, _mm256_permute2x128_si256(v[0], v[1], 0x20));
// StoreAligned32(src + 16, _mm256_permute2x128_si256(v[0], v[1], 0x31));
StoreAligned16(src + 0 * 8, _mm256_extracti128_si256(v[0], 0));
StoreAligned16(src + 1 * 8, _mm256_extracti128_si256(v[1], 0));
StoreAligned16(src + 2 * 8, _mm256_extracti128_si256(v[0], 1));
StoreAligned16(src + 3 * 8, _mm256_extracti128_si256(v[1], 1));
}
// Don't use _mm_cvtepu8_epi16() or _mm_cvtepu16_epi32() in the following
// functions. Some compilers may generate super inefficient code and the whole
// decoder could be 15% slower.
inline __m256i VaddlLo8(const __m256i src0, const __m256i src1) {
const __m256i s0 = _mm256_unpacklo_epi8(src0, _mm256_setzero_si256());
const __m256i s1 = _mm256_unpacklo_epi8(src1, _mm256_setzero_si256());
return _mm256_add_epi16(s0, s1);
}
inline __m256i VaddlHi8(const __m256i src0, const __m256i src1) {
const __m256i s0 = _mm256_unpackhi_epi8(src0, _mm256_setzero_si256());
const __m256i s1 = _mm256_unpackhi_epi8(src1, _mm256_setzero_si256());
return _mm256_add_epi16(s0, s1);
}
inline __m256i VaddwLo8(const __m256i src0, const __m256i src1) {
const __m256i s1 = _mm256_unpacklo_epi8(src1, _mm256_setzero_si256());
return _mm256_add_epi16(src0, s1);
}
inline __m256i VaddwHi8(const __m256i src0, const __m256i src1) {
const __m256i s1 = _mm256_unpackhi_epi8(src1, _mm256_setzero_si256());
return _mm256_add_epi16(src0, s1);
}
inline __m256i VmullNLo8(const __m256i src0, const int src1) {
const __m256i s0 = _mm256_unpacklo_epi16(src0, _mm256_setzero_si256());
return _mm256_madd_epi16(s0, _mm256_set1_epi32(src1));
}
inline __m256i VmullNHi8(const __m256i src0, const int src1) {
const __m256i s0 = _mm256_unpackhi_epi16(src0, _mm256_setzero_si256());
return _mm256_madd_epi16(s0, _mm256_set1_epi32(src1));
}
inline __m128i VmullLo16(const __m128i src0, const __m128i src1) {
const __m128i s0 = _mm_unpacklo_epi16(src0, _mm_setzero_si128());
const __m128i s1 = _mm_unpacklo_epi16(src1, _mm_setzero_si128());
return _mm_madd_epi16(s0, s1);
}
inline __m256i VmullLo16(const __m256i src0, const __m256i src1) {
const __m256i s0 = _mm256_unpacklo_epi16(src0, _mm256_setzero_si256());
const __m256i s1 = _mm256_unpacklo_epi16(src1, _mm256_setzero_si256());
return _mm256_madd_epi16(s0, s1);
}
inline __m128i VmullHi16(const __m128i src0, const __m128i src1) {
const __m128i s0 = _mm_unpackhi_epi16(src0, _mm_setzero_si128());
const __m128i s1 = _mm_unpackhi_epi16(src1, _mm_setzero_si128());
return _mm_madd_epi16(s0, s1);
}
inline __m256i VmullHi16(const __m256i src0, const __m256i src1) {
const __m256i s0 = _mm256_unpackhi_epi16(src0, _mm256_setzero_si256());
const __m256i s1 = _mm256_unpackhi_epi16(src1, _mm256_setzero_si256());
return _mm256_madd_epi16(s0, s1);
}
inline __m128i VrshrU16(const __m128i src0, const int src1) {
const __m128i sum = _mm_add_epi16(src0, _mm_set1_epi16(1 << (src1 - 1)));
return _mm_srli_epi16(sum, src1);
}
inline __m256i VrshrU16(const __m256i src0, const int src1) {
const __m256i sum =
_mm256_add_epi16(src0, _mm256_set1_epi16(1 << (src1 - 1)));
return _mm256_srli_epi16(sum, src1);
}
inline __m256i VrshrS32(const __m256i src0, const int src1) {
const __m256i sum =
_mm256_add_epi32(src0, _mm256_set1_epi32(1 << (src1 - 1)));
return _mm256_srai_epi32(sum, src1);
}
inline __m128i VrshrU32(const __m128i src0, const int src1) {
const __m128i sum = _mm_add_epi32(src0, _mm_set1_epi32(1 << (src1 - 1)));
return _mm_srli_epi32(sum, src1);
}
inline __m256i VrshrU32(const __m256i src0, const int src1) {
const __m256i sum =
_mm256_add_epi32(src0, _mm256_set1_epi32(1 << (src1 - 1)));
return _mm256_srli_epi32(sum, src1);
}
inline void Square(const __m128i src, __m128i dst[2]) {
const __m128i s0 = _mm_unpacklo_epi16(src, _mm_setzero_si128());
const __m128i s1 = _mm_unpackhi_epi16(src, _mm_setzero_si128());
dst[0] = _mm_madd_epi16(s0, s0);
dst[1] = _mm_madd_epi16(s1, s1);
}
inline void Square(const __m256i src, __m256i dst[2]) {
const __m256i s0 = _mm256_unpacklo_epi16(src, _mm256_setzero_si256());
const __m256i s1 = _mm256_unpackhi_epi16(src, _mm256_setzero_si256());
dst[0] = _mm256_madd_epi16(s0, s0);
dst[1] = _mm256_madd_epi16(s1, s1);
}
inline void Prepare3_8(const __m256i src[2], __m256i dst[3]) {
dst[0] = _mm256_alignr_epi8(src[1], src[0], 0);
dst[1] = _mm256_alignr_epi8(src[1], src[0], 1);
dst[2] = _mm256_alignr_epi8(src[1], src[0], 2);
}
inline void Prepare3_16(const __m128i src[2], __m128i dst[3]) {
dst[0] = src[0];
dst[1] = _mm_alignr_epi8(src[1], src[0], 2);
dst[2] = _mm_alignr_epi8(src[1], src[0], 4);
}
inline void Prepare3_32(const __m128i src[2], __m128i dst[3]) {
dst[0] = src[0];
dst[1] = _mm_alignr_epi8(src[1], src[0], 4);
dst[2] = _mm_alignr_epi8(src[1], src[0], 8);
}
inline void Prepare3_32(const __m256i src[2], __m256i dst[3]) {
dst[0] = src[0];
dst[1] = _mm256_alignr_epi8(src[1], src[0], 4);
dst[2] = _mm256_alignr_epi8(src[1], src[0], 8);
}
inline void Prepare5_16(const __m128i src[2], __m128i dst[5]) {
Prepare3_16(src, dst);
dst[3] = _mm_alignr_epi8(src[1], src[0], 6);
dst[4] = _mm_alignr_epi8(src[1], src[0], 8);
}
inline void Prepare5_32(const __m128i src[2], __m128i dst[5]) {
Prepare3_32(src, dst);
dst[3] = _mm_alignr_epi8(src[1], src[0], 12);
dst[4] = src[1];
}
inline void Prepare5_32(const __m256i src[2], __m256i dst[5]) {
Prepare3_32(src, dst);
dst[3] = _mm256_alignr_epi8(src[1], src[0], 12);
dst[4] = src[1];
}
inline __m128i Sum3_16(const __m128i src0, const __m128i src1,
const __m128i src2) {
const __m128i sum = _mm_add_epi16(src0, src1);
return _mm_add_epi16(sum, src2);
}
inline __m256i Sum3_16(const __m256i src0, const __m256i src1,
const __m256i src2) {
const __m256i sum = _mm256_add_epi16(src0, src1);
return _mm256_add_epi16(sum, src2);
}
inline __m128i Sum3_16(const __m128i src[3]) {
return Sum3_16(src[0], src[1], src[2]);
}
inline __m256i Sum3_16(const __m256i src[3]) {
return Sum3_16(src[0], src[1], src[2]);
}
inline __m128i Sum3_32(const __m128i src0, const __m128i src1,
const __m128i src2) {
const __m128i sum = _mm_add_epi32(src0, src1);
return _mm_add_epi32(sum, src2);
}
inline __m256i Sum3_32(const __m256i src0, const __m256i src1,
const __m256i src2) {
const __m256i sum = _mm256_add_epi32(src0, src1);
return _mm256_add_epi32(sum, src2);
}
inline __m128i Sum3_32(const __m128i src[3]) {
return Sum3_32(src[0], src[1], src[2]);
}
inline __m256i Sum3_32(const __m256i src[3]) {
return Sum3_32(src[0], src[1], src[2]);
}
inline void Sum3_32(const __m128i src[3][2], __m128i dst[2]) {
dst[0] = Sum3_32(src[0][0], src[1][0], src[2][0]);
dst[1] = Sum3_32(src[0][1], src[1][1], src[2][1]);
}
inline void Sum3_32(const __m256i src[3][2], __m256i dst[2]) {
dst[0] = Sum3_32(src[0][0], src[1][0], src[2][0]);
dst[1] = Sum3_32(src[0][1], src[1][1], src[2][1]);
}
inline __m256i Sum3WLo16(const __m256i src[3]) {
const __m256i sum = VaddlLo8(src[0], src[1]);
return VaddwLo8(sum, src[2]);
}
inline __m256i Sum3WHi16(const __m256i src[3]) {
const __m256i sum = VaddlHi8(src[0], src[1]);
return VaddwHi8(sum, src[2]);
}
inline __m128i Sum5_16(const __m128i src[5]) {
const __m128i sum01 = _mm_add_epi16(src[0], src[1]);
const __m128i sum23 = _mm_add_epi16(src[2], src[3]);
const __m128i sum = _mm_add_epi16(sum01, sum23);
return _mm_add_epi16(sum, src[4]);
}
inline __m256i Sum5_16(const __m256i src[5]) {
const __m256i sum01 = _mm256_add_epi16(src[0], src[1]);
const __m256i sum23 = _mm256_add_epi16(src[2], src[3]);
const __m256i sum = _mm256_add_epi16(sum01, sum23);
return _mm256_add_epi16(sum, src[4]);
}
inline __m128i Sum5_32(const __m128i* const src0, const __m128i* const src1,
const __m128i* const src2, const __m128i* const src3,
const __m128i* const src4) {
const __m128i sum01 = _mm_add_epi32(*src0, *src1);
const __m128i sum23 = _mm_add_epi32(*src2, *src3);
const __m128i sum = _mm_add_epi32(sum01, sum23);
return _mm_add_epi32(sum, *src4);
}
inline __m256i Sum5_32(const __m256i* const src0, const __m256i* const src1,
const __m256i* const src2, const __m256i* const src3,
const __m256i* const src4) {
const __m256i sum01 = _mm256_add_epi32(*src0, *src1);
const __m256i sum23 = _mm256_add_epi32(*src2, *src3);
const __m256i sum = _mm256_add_epi32(sum01, sum23);
return _mm256_add_epi32(sum, *src4);
}
inline __m128i Sum5_32(const __m128i src[5]) {
return Sum5_32(&src[0], &src[1], &src[2], &src[3], &src[4]);
}
inline __m256i Sum5_32(const __m256i src[5]) {
return Sum5_32(&src[0], &src[1], &src[2], &src[3], &src[4]);
}
inline void Sum5_32(const __m128i src[5][2], __m128i dst[2]) {
dst[0] = Sum5_32(&src[0][0], &src[1][0], &src[2][0], &src[3][0], &src[4][0]);
dst[1] = Sum5_32(&src[0][1], &src[1][1], &src[2][1], &src[3][1], &src[4][1]);
}
inline void Sum5_32(const __m256i src[5][2], __m256i dst[2]) {
dst[0] = Sum5_32(&src[0][0], &src[1][0], &src[2][0], &src[3][0], &src[4][0]);
dst[1] = Sum5_32(&src[0][1], &src[1][1], &src[2][1], &src[3][1], &src[4][1]);
}
inline __m128i Sum3Horizontal16(const __m128i src[2]) {
__m128i s[3];
Prepare3_16(src, s);
return Sum3_16(s);
}
inline __m256i Sum3Horizontal16(const uint16_t* const src,
const ptrdiff_t over_read_in_bytes) {
__m256i s[3];
s[0] = LoadUnaligned32Msan(src + 0, over_read_in_bytes + 0);
s[1] = LoadUnaligned32Msan(src + 1, over_read_in_bytes + 2);
s[2] = LoadUnaligned32Msan(src + 2, over_read_in_bytes + 4);
return Sum3_16(s);
}
inline __m128i Sum5Horizontal16(const __m128i src[2]) {
__m128i s[5];
Prepare5_16(src, s);
return Sum5_16(s);
}
inline __m256i Sum5Horizontal16(const uint16_t* const src,
const ptrdiff_t over_read_in_bytes) {
__m256i s[5];
s[0] = LoadUnaligned32Msan(src + 0, over_read_in_bytes + 0);
s[1] = LoadUnaligned32Msan(src + 1, over_read_in_bytes + 2);
s[2] = LoadUnaligned32Msan(src + 2, over_read_in_bytes + 4);
s[3] = LoadUnaligned32Msan(src + 3, over_read_in_bytes + 6);
s[4] = LoadUnaligned32Msan(src + 4, over_read_in_bytes + 8);
return Sum5_16(s);
}
inline void SumHorizontal16(const uint16_t* const src,
const ptrdiff_t over_read_in_bytes,
__m256i* const row3, __m256i* const row5) {
__m256i s[5];
s[0] = LoadUnaligned32Msan(src + 0, over_read_in_bytes + 0);
s[1] = LoadUnaligned32Msan(src + 1, over_read_in_bytes + 2);
s[2] = LoadUnaligned32Msan(src + 2, over_read_in_bytes + 4);
s[3] = LoadUnaligned32Msan(src + 3, over_read_in_bytes + 6);
s[4] = LoadUnaligned32Msan(src + 4, over_read_in_bytes + 8);
const __m256i sum04 = _mm256_add_epi16(s[0], s[4]);
*row3 = Sum3_16(s + 1);
*row5 = _mm256_add_epi16(sum04, *row3);
}
inline void SumHorizontal16(const uint16_t* const src,
const ptrdiff_t over_read_in_bytes,
__m256i* const row3_0, __m256i* const row3_1,
__m256i* const row5_0, __m256i* const row5_1) {
SumHorizontal16(src + 0, over_read_in_bytes + 0, row3_0, row5_0);
SumHorizontal16(src + 16, over_read_in_bytes + 32, row3_1, row5_1);
}
inline void SumHorizontal32(const __m128i src[5], __m128i* const row_sq3,
__m128i* const row_sq5) {
const __m128i sum04 = _mm_add_epi32(src[0], src[4]);
*row_sq3 = Sum3_32(src + 1);
*row_sq5 = _mm_add_epi32(sum04, *row_sq3);
}
inline void SumHorizontal32(const __m256i src[5], __m256i* const row_sq3,
__m256i* const row_sq5) {
const __m256i sum04 = _mm256_add_epi32(src[0], src[4]);
*row_sq3 = Sum3_32(src + 1);
*row_sq5 = _mm256_add_epi32(sum04, *row_sq3);
}
inline void SumHorizontal32(const __m128i src[3], __m128i* const row_sq3_0,
__m128i* const row_sq3_1, __m128i* const row_sq5_0,
__m128i* const row_sq5_1) {
__m128i s[5];
Prepare5_32(src + 0, s);
SumHorizontal32(s, row_sq3_0, row_sq5_0);
Prepare5_32(src + 1, s);
SumHorizontal32(s, row_sq3_1, row_sq5_1);
}
inline void SumHorizontal32(const __m256i src[3], __m256i* const row_sq3_0,
__m256i* const row_sq3_1, __m256i* const row_sq5_0,
__m256i* const row_sq5_1) {
__m256i s[5];
Prepare5_32(src + 0, s);
SumHorizontal32(s, row_sq3_0, row_sq5_0);
Prepare5_32(src + 1, s);
SumHorizontal32(s, row_sq3_1, row_sq5_1);
}
inline void Sum3Horizontal32(const __m128i src[3], __m128i dst[2]) {
__m128i s[3];
Prepare3_32(src + 0, s);
dst[0] = Sum3_32(s);
Prepare3_32(src + 1, s);
dst[1] = Sum3_32(s);
}
inline void Sum3Horizontal32(const __m256i src[3], __m256i dst[2]) {
__m256i s[3];
Prepare3_32(src + 0, s);
dst[0] = Sum3_32(s);
Prepare3_32(src + 1, s);
dst[1] = Sum3_32(s);
}
inline void Sum5Horizontal32(const __m128i src[3], __m128i dst[2]) {
__m128i s[5];
Prepare5_32(src + 0, s);
dst[0] = Sum5_32(s);
Prepare5_32(src + 1, s);
dst[1] = Sum5_32(s);
}
inline void Sum5Horizontal32(const __m256i src[3], __m256i dst[2]) {
__m256i s[5];
Prepare5_32(src + 0, s);
dst[0] = Sum5_32(s);
Prepare5_32(src + 1, s);
dst[1] = Sum5_32(s);
}
void SumHorizontal16(const __m128i src[2], __m128i* const row3,
__m128i* const row5) {
__m128i s[5];
Prepare5_16(src, s);
const __m128i sum04 = _mm_add_epi16(s[0], s[4]);
*row3 = Sum3_16(s + 1);
*row5 = _mm_add_epi16(sum04, *row3);
}
inline __m256i Sum343Lo(const __m256i ma3[3]) {
const __m256i sum = Sum3WLo16(ma3);
const __m256i sum3 = Sum3_16(sum, sum, sum);
return VaddwLo8(sum3, ma3[1]);
}
inline __m256i Sum343Hi(const __m256i ma3[3]) {
const __m256i sum = Sum3WHi16(ma3);
const __m256i sum3 = Sum3_16(sum, sum, sum);
return VaddwHi8(sum3, ma3[1]);
}
inline __m256i Sum343(const __m256i src[3]) {
const __m256i sum = Sum3_32(src);
const __m256i sum3 = Sum3_32(sum, sum, sum);
return _mm256_add_epi32(sum3, src[1]);
}
inline void Sum343(const __m256i src[3], __m256i dst[2]) {
__m256i s[3];
Prepare3_32(src + 0, s);
dst[0] = Sum343(s);
Prepare3_32(src + 1, s);
dst[1] = Sum343(s);
}
inline __m256i Sum565Lo(const __m256i src[3]) {
const __m256i sum = Sum3WLo16(src);
const __m256i sum4 = _mm256_slli_epi16(sum, 2);
const __m256i sum5 = _mm256_add_epi16(sum4, sum);
return VaddwLo8(sum5, src[1]);
}
inline __m256i Sum565Hi(const __m256i src[3]) {
const __m256i sum = Sum3WHi16(src);
const __m256i sum4 = _mm256_slli_epi16(sum, 2);
const __m256i sum5 = _mm256_add_epi16(sum4, sum);
return VaddwHi8(sum5, src[1]);
}
inline __m256i Sum565(const __m256i src[3]) {
const __m256i sum = Sum3_32(src);
const __m256i sum4 = _mm256_slli_epi32(sum, 2);
const __m256i sum5 = _mm256_add_epi32(sum4, sum);
return _mm256_add_epi32(sum5, src[1]);
}
inline void Sum565(const __m256i src[3], __m256i dst[2]) {
__m256i s[3];
Prepare3_32(src + 0, s);
dst[0] = Sum565(s);
Prepare3_32(src + 1, s);
dst[1] = Sum565(s);
}
inline void BoxSum(const uint16_t* src, const ptrdiff_t src_stride,
const ptrdiff_t width, const ptrdiff_t sum_stride,
const ptrdiff_t sum_width, uint16_t* sum3, uint16_t* sum5,
uint32_t* square_sum3, uint32_t* square_sum5) {
const ptrdiff_t overread_in_bytes_128 =
kOverreadInBytesPass1_128 - sizeof(*src) * width;
const ptrdiff_t overread_in_bytes_256 =
kOverreadInBytesPass1_256 - sizeof(*src) * width;
int y = 2;
do {
__m128i s0[2], sq_128[4], s3, s5, sq3[2], sq5[2];
__m256i sq[8];
s0[0] = LoadUnaligned16Msan(src + 0, overread_in_bytes_128 + 0);
s0[1] = LoadUnaligned16Msan(src + 8, overread_in_bytes_128 + 16);
Square(s0[0], sq_128 + 0);
Square(s0[1], sq_128 + 2);
SumHorizontal16(s0, &s3, &s5);
StoreAligned16(sum3, s3);
StoreAligned16(sum5, s5);
SumHorizontal32(sq_128, &sq3[0], &sq3[1], &sq5[0], &sq5[1]);
StoreAligned32U32(square_sum3, sq3);
StoreAligned32U32(square_sum5, sq5);
src += 8;
sum3 += 8;
sum5 += 8;
square_sum3 += 8;
square_sum5 += 8;
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
ptrdiff_t x = sum_width;
do {
__m256i s[2], row3[2], row5[2], row_sq3[2], row_sq5[2];
s[0] = LoadUnaligned32Msan(
src + 8, overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 8));
s[1] = LoadUnaligned32Msan(
src + 24,
overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 24));
Square(s[0], sq + 2);
Square(s[1], sq + 6);
sq[0] = _mm256_permute2x128_si256(sq[0], sq[2], 0x21);
sq[1] = _mm256_permute2x128_si256(sq[1], sq[3], 0x21);
sq[4] = _mm256_permute2x128_si256(sq[2], sq[6], 0x21);
sq[5] = _mm256_permute2x128_si256(sq[3], sq[7], 0x21);
SumHorizontal16(
src, overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 8),
&row3[0], &row3[1], &row5[0], &row5[1]);
StoreAligned64(sum3, row3);
StoreAligned64(sum5, row5);
SumHorizontal32(sq + 0, &row_sq3[0], &row_sq3[1], &row_sq5[0],
&row_sq5[1]);
StoreAligned64(square_sum3 + 0, row_sq3);
StoreAligned64(square_sum5 + 0, row_sq5);
SumHorizontal32(sq + 4, &row_sq3[0], &row_sq3[1], &row_sq5[0],
&row_sq5[1]);
StoreAligned64(square_sum3 + 16, row_sq3);
StoreAligned64(square_sum5 + 16, row_sq5);
sq[0] = sq[6];
sq[1] = sq[7];
src += 32;
sum3 += 32;
sum5 += 32;
square_sum3 += 32;
square_sum5 += 32;
x -= 32;
} while (x != 0);
src += src_stride - sum_width - 8;
sum3 += sum_stride - sum_width - 8;
sum5 += sum_stride - sum_width - 8;
square_sum3 += sum_stride - sum_width - 8;
square_sum5 += sum_stride - sum_width - 8;
} while (--y != 0);
}
template <int size>
inline void BoxSum(const uint16_t* src, const ptrdiff_t src_stride,
const ptrdiff_t width, const ptrdiff_t sum_stride,
const ptrdiff_t sum_width, uint16_t* sums,
uint32_t* square_sums) {
static_assert(size == 3 || size == 5, "");
int overread_in_bytes_128, overread_in_bytes_256;
if (size == 3) {
overread_in_bytes_128 = kOverreadInBytesPass2_128;
overread_in_bytes_256 = kOverreadInBytesPass2_256;
} else {
overread_in_bytes_128 = kOverreadInBytesPass1_128;
overread_in_bytes_256 = kOverreadInBytesPass1_256;
}
overread_in_bytes_128 -= sizeof(*src) * width;
overread_in_bytes_256 -= sizeof(*src) * width;
int y = 2;
do {
__m128i s_128[2], ss, sq_128[4], sqs[2];
__m256i sq[8];
s_128[0] = LoadUnaligned16Msan(src + 0, overread_in_bytes_128);
s_128[1] = LoadUnaligned16Msan(src + 8, overread_in_bytes_128 + 16);
Square(s_128[0], sq_128 + 0);
Square(s_128[1], sq_128 + 2);
if (size == 3) {
ss = Sum3Horizontal16(s_128);
Sum3Horizontal32(sq_128, sqs);
} else {
ss = Sum5Horizontal16(s_128);
Sum5Horizontal32(sq_128, sqs);
}
StoreAligned16(sums, ss);
StoreAligned32U32(square_sums, sqs);
src += 8;
sums += 8;
square_sums += 8;
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
ptrdiff_t x = sum_width;
do {
__m256i s[2], row[2], row_sq[4];
s[0] = LoadUnaligned32Msan(
src + 8, overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 8));
s[1] = LoadUnaligned32Msan(
src + 24,
overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 24));
Square(s[0], sq + 2);
Square(s[1], sq + 6);
sq[0] = _mm256_permute2x128_si256(sq[0], sq[2], 0x21);
sq[1] = _mm256_permute2x128_si256(sq[1], sq[3], 0x21);
sq[4] = _mm256_permute2x128_si256(sq[2], sq[6], 0x21);
sq[5] = _mm256_permute2x128_si256(sq[3], sq[7], 0x21);
if (size == 3) {
row[0] = Sum3Horizontal16(
src, overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 8));
row[1] =
Sum3Horizontal16(src + 16, overread_in_bytes_256 +
sizeof(*src) * (sum_width - x + 24));
Sum3Horizontal32(sq + 0, row_sq + 0);
Sum3Horizontal32(sq + 4, row_sq + 2);
} else {
row[0] = Sum5Horizontal16(
src, overread_in_bytes_256 + sizeof(*src) * (sum_width - x + 8));
row[1] =
Sum5Horizontal16(src + 16, overread_in_bytes_256 +
sizeof(*src) * (sum_width - x + 24));
Sum5Horizontal32(sq + 0, row_sq + 0);
Sum5Horizontal32(sq + 4, row_sq + 2);
}
StoreAligned64(sums, row);
StoreAligned64(square_sums + 0, row_sq + 0);
StoreAligned64(square_sums + 16, row_sq + 2);
sq[0] = sq[6];
sq[1] = sq[7];
src += 32;
sums += 32;
square_sums += 32;
x -= 32;
} while (x != 0);
src += src_stride - sum_width - 8;
sums += sum_stride - sum_width - 8;
square_sums += sum_stride - sum_width - 8;
} while (--y != 0);
}
template <int n>
inline __m128i CalculateMa(const __m128i sum, const __m128i sum_sq,
const uint32_t scale) {
static_assert(n == 9 || n == 25, "");
// a = |sum_sq|
// d = |sum|
// p = (a * n < d * d) ? 0 : a * n - d * d;
const __m128i dxd = _mm_madd_epi16(sum, sum);
// _mm_mullo_epi32() has high latency. Using shifts and additions instead.
// Some compilers could do this for us but we make this explicit.
// return _mm_mullo_epi32(sum_sq, _mm_set1_epi32(n));
__m128i axn = _mm_add_epi32(sum_sq, _mm_slli_epi32(sum_sq, 3));
if (n == 25) axn = _mm_add_epi32(axn, _mm_slli_epi32(sum_sq, 4));
const __m128i sub = _mm_sub_epi32(axn, dxd);
const __m128i p = _mm_max_epi32(sub, _mm_setzero_si128());
const __m128i pxs = _mm_mullo_epi32(p, _mm_set1_epi32(scale));
return VrshrU32(pxs, kSgrProjScaleBits);
}
template <int n>
inline __m128i CalculateMa(const __m128i sum, const __m128i sum_sq[2],
const uint32_t scale) {
static_assert(n == 9 || n == 25, "");
const __m128i b = VrshrU16(sum, 2);
const __m128i sum_lo = _mm_unpacklo_epi16(b, _mm_setzero_si128());
const __m128i sum_hi = _mm_unpackhi_epi16(b, _mm_setzero_si128());
const __m128i z0 = CalculateMa<n>(sum_lo, VrshrU32(sum_sq[0], 4), scale);
const __m128i z1 = CalculateMa<n>(sum_hi, VrshrU32(sum_sq[1], 4), scale);
return _mm_packus_epi32(z0, z1);
}
template <int n>
inline __m256i CalculateMa(const __m256i sum, const __m256i sum_sq,
const uint32_t scale) {
static_assert(n == 9 || n == 25, "");
// a = |sum_sq|
// d = |sum|
// p = (a * n < d * d) ? 0 : a * n - d * d;
const __m256i dxd = _mm256_madd_epi16(sum, sum);
// _mm256_mullo_epi32() has high latency. Using shifts and additions instead.
// Some compilers could do this for us but we make this explicit.
// return _mm256_mullo_epi32(sum_sq, _mm256_set1_epi32(n));
__m256i axn = _mm256_add_epi32(sum_sq, _mm256_slli_epi32(sum_sq, 3));
if (n == 25) axn = _mm256_add_epi32(axn, _mm256_slli_epi32(sum_sq, 4));
const __m256i sub = _mm256_sub_epi32(axn, dxd);
const __m256i p = _mm256_max_epi32(sub, _mm256_setzero_si256());
const __m256i pxs = _mm256_mullo_epi32(p, _mm256_set1_epi32(scale));
return VrshrU32(pxs, kSgrProjScaleBits);
}
template <int n>
inline __m256i CalculateMa(const __m256i sum, const __m256i sum_sq[2],
const uint32_t scale) {
static_assert(n == 9 || n == 25, "");
const __m256i b = VrshrU16(sum, 2);
const __m256i sum_lo = _mm256_unpacklo_epi16(b, _mm256_setzero_si256());
const __m256i sum_hi = _mm256_unpackhi_epi16(b, _mm256_setzero_si256());
const __m256i z0 = CalculateMa<n>(sum_lo, VrshrU32(sum_sq[0], 4), scale);
const __m256i z1 = CalculateMa<n>(sum_hi, VrshrU32(sum_sq[1], 4), scale);
return _mm256_packus_epi32(z0, z1);
}
inline void CalculateB5(const __m128i sum, const __m128i ma, __m128i b[2]) {
// one_over_n == 164.
constexpr uint32_t one_over_n =
((1 << kSgrProjReciprocalBits) + (25 >> 1)) / 25;
// one_over_n_quarter == 41.
constexpr uint32_t one_over_n_quarter = one_over_n >> 2;
static_assert(one_over_n == one_over_n_quarter << 2, "");
// |ma| is in range [0, 255].
const __m128i m = _mm_maddubs_epi16(ma, _mm_set1_epi16(one_over_n_quarter));
const __m128i m0 = VmullLo16(m, sum);
const __m128i m1 = VmullHi16(m, sum);
b[0] = VrshrU32(m0, kSgrProjReciprocalBits - 2);
b[1] = VrshrU32(m1, kSgrProjReciprocalBits - 2);
}
inline void CalculateB5(const __m256i sum, const __m256i ma, __m256i b[2]) {
// one_over_n == 164.
constexpr uint32_t one_over_n =
((1 << kSgrProjReciprocalBits) + (25 >> 1)) / 25;
// one_over_n_quarter == 41.
constexpr uint32_t one_over_n_quarter = one_over_n >> 2;
static_assert(one_over_n == one_over_n_quarter << 2, "");
// |ma| is in range [0, 255].
const __m256i m =
_mm256_maddubs_epi16(ma, _mm256_set1_epi16(one_over_n_quarter));
const __m256i m0 = VmullLo16(m, sum);
const __m256i m1 = VmullHi16(m, sum);
b[0] = VrshrU32(m0, kSgrProjReciprocalBits - 2);
b[1] = VrshrU32(m1, kSgrProjReciprocalBits - 2);
}
inline void CalculateB3(const __m128i sum, const __m128i ma, __m128i b[2]) {
// one_over_n == 455.
constexpr uint32_t one_over_n =
((1 << kSgrProjReciprocalBits) + (9 >> 1)) / 9;
const __m128i m0 = VmullLo16(ma, sum);
const __m128i m1 = VmullHi16(ma, sum);
const __m128i m2 = _mm_mullo_epi32(m0, _mm_set1_epi32(one_over_n));
const __m128i m3 = _mm_mullo_epi32(m1, _mm_set1_epi32(one_over_n));
b[0] = VrshrU32(m2, kSgrProjReciprocalBits);
b[1] = VrshrU32(m3, kSgrProjReciprocalBits);
}
inline void CalculateB3(const __m256i sum, const __m256i ma, __m256i b[2]) {
// one_over_n == 455.
constexpr uint32_t one_over_n =
((1 << kSgrProjReciprocalBits) + (9 >> 1)) / 9;
const __m256i m0 = VmullLo16(ma, sum);
const __m256i m1 = VmullHi16(ma, sum);
const __m256i m2 = _mm256_mullo_epi32(m0, _mm256_set1_epi32(one_over_n));
const __m256i m3 = _mm256_mullo_epi32(m1, _mm256_set1_epi32(one_over_n));
b[0] = VrshrU32(m2, kSgrProjReciprocalBits);
b[1] = VrshrU32(m3, kSgrProjReciprocalBits);
}
inline void CalculateSumAndIndex5(const __m128i s5[5], const __m128i sq5[5][2],
const uint32_t scale, __m128i* const sum,
__m128i* const index) {
__m128i sum_sq[2];
*sum = Sum5_16(s5);
Sum5_32(sq5, sum_sq);
*index = CalculateMa<25>(*sum, sum_sq, scale);
}
inline void CalculateSumAndIndex5(const __m256i s5[5], const __m256i sq5[5][2],
const uint32_t scale, __m256i* const sum,
__m256i* const index) {
__m256i sum_sq[2];
*sum = Sum5_16(s5);
Sum5_32(sq5, sum_sq);
*index = CalculateMa<25>(*sum, sum_sq, scale);
}
inline void CalculateSumAndIndex3(const __m128i s3[3], const __m128i sq3[3][2],
const uint32_t scale, __m128i* const sum,
__m128i* const index) {
__m128i sum_sq[2];
*sum = Sum3_16(s3);
Sum3_32(sq3, sum_sq);
*index = CalculateMa<9>(*sum, sum_sq, scale);
}
inline void CalculateSumAndIndex3(const __m256i s3[3], const __m256i sq3[3][2],
const uint32_t scale, __m256i* const sum,
__m256i* const index) {
__m256i sum_sq[2];
*sum = Sum3_16(s3);
Sum3_32(sq3, sum_sq);
*index = CalculateMa<9>(*sum, sum_sq, scale);
}
template <int n>
inline void LookupIntermediate(const __m128i sum, const __m128i index,
__m128i* const ma, __m128i b[2]) {
static_assert(n == 9 || n == 25, "");
const __m128i idx = _mm_packus_epi16(index, index);
// Actually it's not stored and loaded. The compiler will use a 64-bit
// general-purpose register to process. Faster than using _mm_extract_epi8().
uint8_t temp[8];
StoreLo8(temp, idx);
*ma = _mm_cvtsi32_si128(kSgrMaLookup[temp[0]]);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[1]], 1);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[2]], 2);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[3]], 3);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[4]], 4);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[5]], 5);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[6]], 6);
*ma = _mm_insert_epi8(*ma, kSgrMaLookup[temp[7]], 7);
// b = ma * b * one_over_n
// |ma| = [0, 255]
// |sum| is a box sum with radius 1 or 2.
// For the first pass radius is 2. Maximum value is 5x5x255 = 6375.
// For the second pass radius is 1. Maximum value is 3x3x255 = 2295.
// |one_over_n| = ((1 << kSgrProjReciprocalBits) + (n >> 1)) / n
// When radius is 2 |n| is 25. |one_over_n| is 164.
// When radius is 1 |n| is 9. |one_over_n| is 455.
// |kSgrProjReciprocalBits| is 12.
// Radius 2: 255 * 6375 * 164 >> 12 = 65088 (16 bits).
// Radius 1: 255 * 2295 * 455 >> 12 = 65009 (16 bits).
const __m128i maq = _mm_unpacklo_epi8(*ma, _mm_setzero_si128());
if (n == 9) {
CalculateB3(sum, maq, b);
} else {
CalculateB5(sum, maq, b);
}
}
// Repeat the first 48 elements in kSgrMaLookup with a period of 16.
alignas(32) constexpr uint8_t kSgrMaLookupAvx2[96] = {
255, 128, 85, 64, 51, 43, 37, 32, 28, 26, 23, 21, 20, 18, 17, 16,
255, 128, 85, 64, 51, 43, 37, 32, 28, 26, 23, 21, 20, 18, 17, 16,
15, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 9, 9, 8, 8,
15, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 9, 9, 8, 8,
8, 8, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5,
8, 8, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 5, 5};
// Set the shuffle control mask of indices out of range [0, 15] to (1xxxxxxx)b
// to get value 0 as the shuffle result. The most significiant bit 1 comes
// either from the comparison instruction, or from the sign bit of the index.
inline __m128i ShuffleIndex(const __m128i table, const __m128i index) {
__m128i mask;
mask = _mm_cmpgt_epi8(index, _mm_set1_epi8(15));
mask = _mm_or_si128(mask, index);
return _mm_shuffle_epi8(table, mask);
}
inline __m256i ShuffleIndex(const __m256i table, const __m256i index) {
__m256i mask;
mask = _mm256_cmpgt_epi8(index, _mm256_set1_epi8(15));
mask = _mm256_or_si256(mask, index);
return _mm256_shuffle_epi8(table, mask);
}
inline __m128i AdjustValue(const __m128i value, const __m128i index,
const int threshold) {
const __m128i thresholds = _mm_set1_epi8(threshold - 128);
const __m128i offset = _mm_cmpgt_epi8(index, thresholds);
return _mm_add_epi8(value, offset);
}
inline __m256i AdjustValue(const __m256i value, const __m256i index,
const int threshold) {
const __m256i thresholds = _mm256_set1_epi8(threshold - 128);
const __m256i offset = _mm256_cmpgt_epi8(index, thresholds);
return _mm256_add_epi8(value, offset);
}
inline void CalculateIntermediate(const __m128i sum[2], const __m128i index[2],
__m128i* const ma, __m128i b0[2],
__m128i b1[2]) {
// Use table lookup to read elements whose indices are less than 48.
const __m128i c0 = LoadAligned16(kSgrMaLookup + 0 * 16);
const __m128i c1 = LoadAligned16(kSgrMaLookup + 1 * 16);
const __m128i c2 = LoadAligned16(kSgrMaLookup + 2 * 16);
const __m128i indices = _mm_packus_epi16(index[0], index[1]);
__m128i idx;
// Clip idx to 127 to apply signed comparison instructions.
idx = _mm_min_epu8(indices, _mm_set1_epi8(127));
// All elements whose indices are less than 48 are set to 0.
// Get shuffle results for indices in range [0, 15].
*ma = ShuffleIndex(c0, idx);
// Get shuffle results for indices in range [16, 31].
// Subtract 16 to utilize the sign bit of the index.
idx = _mm_sub_epi8(idx, _mm_set1_epi8(16));
const __m128i res1 = ShuffleIndex(c1, idx);
// Use OR instruction to combine shuffle results together.
*ma = _mm_or_si128(*ma, res1);
// Get shuffle results for indices in range [32, 47].
// Subtract 16 to utilize the sign bit of the index.
idx = _mm_sub_epi8(idx, _mm_set1_epi8(16));
const __m128i res2 = ShuffleIndex(c2, idx);
*ma = _mm_or_si128(*ma, res2);
// For elements whose indices are larger than 47, since they seldom change
// values with the increase of the index, we use comparison and arithmetic
// operations to calculate their values.
// Add -128 to apply signed comparison instructions.
idx = _mm_add_epi8(indices, _mm_set1_epi8(-128));
// Elements whose indices are larger than 47 (with value 0) are set to 5.
*ma = _mm_max_epu8(*ma, _mm_set1_epi8(5));
*ma = AdjustValue(*ma, idx, 55); // 55 is the last index which value is 5.
*ma = AdjustValue(*ma, idx, 72); // 72 is the last index which value is 4.
*ma = AdjustValue(*ma, idx, 101); // 101 is the last index which value is 3.
*ma = AdjustValue(*ma, idx, 169); // 169 is the last index which value is 2.
*ma = AdjustValue(*ma, idx, 254); // 254 is the last index which value is 1.
// b = ma * b * one_over_n
// |ma| = [0, 255]
// |sum| is a box sum with radius 1 or 2.
// For the first pass radius is 2. Maximum value is 5x5x255 = 6375.
// For the second pass radius is 1. Maximum value is 3x3x255 = 2295.
// |one_over_n| = ((1 << kSgrProjReciprocalBits) + (n >> 1)) / n
// When radius is 2 |n| is 25. |one_over_n| is 164.
// When radius is 1 |n| is 9. |one_over_n| is 455.
// |kSgrProjReciprocalBits| is 12.
// Radius 2: 255 * 6375 * 164 >> 12 = 65088 (16 bits).
// Radius 1: 255 * 2295 * 455 >> 12 = 65009 (16 bits).
const __m128i maq0 = _mm_unpacklo_epi8(*ma, _mm_setzero_si128());
CalculateB3(sum[0], maq0, b0);
const __m128i maq1 = _mm_unpackhi_epi8(*ma, _mm_setzero_si128());
CalculateB3(sum[1], maq1, b1);
}
template <int n>
inline void CalculateIntermediate(const __m256i sum[2], const __m256i index[2],
__m256i ma[3], __m256i b0[2], __m256i b1[2]) {
static_assert(n == 9 || n == 25, "");
// Use table lookup to read elements whose indices are less than 48.
const __m256i c0 = LoadAligned32(kSgrMaLookupAvx2 + 0 * 32);
const __m256i c1 = LoadAligned32(kSgrMaLookupAvx2 + 1 * 32);
const __m256i c2 = LoadAligned32(kSgrMaLookupAvx2 + 2 * 32);
const __m256i indices = _mm256_packus_epi16(index[0], index[1]); // 0 2 1 3
__m256i idx, mas;
// Clip idx to 127 to apply signed comparison instructions.
idx = _mm256_min_epu8(indices, _mm256_set1_epi8(127));
// All elements whose indices are less than 48 are set to 0.
// Get shuffle results for indices in range [0, 15].
mas = ShuffleIndex(c0, idx);
// Get shuffle results for indices in range [16, 31].
// Subtract 16 to utilize the sign bit of the index.
idx = _mm256_sub_epi8(idx, _mm256_set1_epi8(16));
const __m256i res1 = ShuffleIndex(c1, idx);
// Use OR instruction to combine shuffle results together.
mas = _mm256_or_si256(mas, res1);
// Get shuffle results for indices in range [32, 47].
// Subtract 16 to utilize the sign bit of the index.
idx = _mm256_sub_epi8(idx, _mm256_set1_epi8(16));
const __m256i res2 = ShuffleIndex(c2, idx);
mas = _mm256_or_si256(mas, res2);
// For elements whose indices are larger than 47, since they seldom change
// values with the increase of the index, we use comparison and arithmetic
// operations to calculate their values.
// Add -128 to apply signed comparison instructions.
idx = _mm256_add_epi8(indices, _mm256_set1_epi8(-128));
// Elements whose indices are larger than 47 (with value 0) are set to 5.
mas = _mm256_max_epu8(mas, _mm256_set1_epi8(5));
mas = AdjustValue(mas, idx, 55); // 55 is the last index which value is 5.
mas = AdjustValue(mas, idx, 72); // 72 is the last index which value is 4.
mas = AdjustValue(mas, idx, 101); // 101 is the last index which value is 3.
mas = AdjustValue(mas, idx, 169); // 169 is the last index which value is 2.
mas = AdjustValue(mas, idx, 254); // 254 is the last index which value is 1.
ma[2] = _mm256_permute4x64_epi64(mas, 0x63); // 32-39 8-15 16-23 24-31
ma[0] = _mm256_blend_epi32(ma[0], ma[2], 0xfc); // 0-7 8-15 16-23 24-31
ma[1] = _mm256_permute2x128_si256(ma[0], ma[2], 0x21);
// b = ma * b * one_over_n
// |ma| = [0, 255]
// |sum| is a box sum with radius 1 or 2.
// For the first pass radius is 2. Maximum value is 5x5x255 = 6375.
// For the second pass radius is 1. Maximum value is 3x3x255 = 2295.
// |one_over_n| = ((1 << kSgrProjReciprocalBits) + (n >> 1)) / n
// When radius is 2 |n| is 25. |one_over_n| is 164.
// When radius is 1 |n| is 9. |one_over_n| is 455.
// |kSgrProjReciprocalBits| is 12.
// Radius 2: 255 * 6375 * 164 >> 12 = 65088 (16 bits).
// Radius 1: 255 * 2295 * 455 >> 12 = 65009 (16 bits).
const __m256i maq0 = _mm256_unpackhi_epi8(ma[0], _mm256_setzero_si256());
const __m256i maq1 = _mm256_unpacklo_epi8(ma[1], _mm256_setzero_si256());
__m256i sums[2];
sums[0] = _mm256_permute2x128_si256(sum[0], sum[1], 0x20);
sums[1] = _mm256_permute2x128_si256(sum[0], sum[1], 0x31);
if (n == 9) {
CalculateB3(sums[0], maq0, b0);
CalculateB3(sums[1], maq1, b1);
} else {
CalculateB5(sums[0], maq0, b0);
CalculateB5(sums[1], maq1, b1);
}
}
inline void CalculateIntermediate5(const __m128i s5[5], const __m128i sq5[5][2],
const uint32_t scale, __m128i* const ma,
__m128i b[2]) {
__m128i sum, index;
CalculateSumAndIndex5(s5, sq5, scale, &sum, &index);
LookupIntermediate<25>(sum, index, ma, b);
}
inline void CalculateIntermediate3(const __m128i s3[3], const __m128i sq3[3][2],
const uint32_t scale, __m128i* const ma,
__m128i b[2]) {
__m128i sum, index;
CalculateSumAndIndex3(s3, sq3, scale, &sum, &index);
LookupIntermediate<9>(sum, index, ma, b);
}
inline void Store343_444(const __m256i b3[3], const ptrdiff_t x,
__m256i sum_b343[2], __m256i sum_b444[2],
uint32_t* const b343, uint32_t* const b444) {
__m256i b[3], sum_b111[2];
Prepare3_32(b3 + 0, b);
sum_b111[0] = Sum3_32(b);
sum_b444[0] = _mm256_slli_epi32(sum_b111[0], 2);
sum_b343[0] = _mm256_sub_epi32(sum_b444[0], sum_b111[0]);
sum_b343[0] = _mm256_add_epi32(sum_b343[0], b[1]);
Prepare3_32(b3 + 1, b);
sum_b111[1] = Sum3_32(b);
sum_b444[1] = _mm256_slli_epi32(sum_b111[1], 2);
sum_b343[1] = _mm256_sub_epi32(sum_b444[1], sum_b111[1]);
sum_b343[1] = _mm256_add_epi32(sum_b343[1], b[1]);
StoreAligned64(b444 + x, sum_b444);
StoreAligned64(b343 + x, sum_b343);
}
inline void Store343_444Lo(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, __m256i* const sum_ma343,
__m256i* const sum_ma444, __m256i sum_b343[2],
__m256i sum_b444[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
const __m256i sum_ma111 = Sum3WLo16(ma3);
*sum_ma444 = _mm256_slli_epi16(sum_ma111, 2);
StoreAligned32_ma(ma444 + x, *sum_ma444);
const __m256i sum333 = _mm256_sub_epi16(*sum_ma444, sum_ma111);
*sum_ma343 = VaddwLo8(sum333, ma3[1]);
StoreAligned32_ma(ma343 + x, *sum_ma343);
Store343_444(b3, x, sum_b343, sum_b444, b343, b444);
}
inline void Store343_444Hi(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, __m256i* const sum_ma343,
__m256i* const sum_ma444, __m256i sum_b343[2],
__m256i sum_b444[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
const __m256i sum_ma111 = Sum3WHi16(ma3);
*sum_ma444 = _mm256_slli_epi16(sum_ma111, 2);
StoreAligned32_ma(ma444 + x, *sum_ma444);
const __m256i sum333 = _mm256_sub_epi16(*sum_ma444, sum_ma111);
*sum_ma343 = VaddwHi8(sum333, ma3[1]);
StoreAligned32_ma(ma343 + x, *sum_ma343);
Store343_444(b3, x + kMaStoreOffset, sum_b343, sum_b444, b343, b444);
}
inline void Store343_444Lo(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, __m256i* const sum_ma343,
__m256i sum_b343[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_ma444, sum_b444[2];
Store343_444Lo(ma3, b3, x, sum_ma343, &sum_ma444, sum_b343, sum_b444, ma343,
ma444, b343, b444);
}
inline void Store343_444Hi(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, __m256i* const sum_ma343,
__m256i sum_b343[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_ma444, sum_b444[2];
Store343_444Hi(ma3, b3, x, sum_ma343, &sum_ma444, sum_b343, sum_b444, ma343,
ma444, b343, b444);
}
inline void Store343_444Lo(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_ma343, sum_b343[2];
Store343_444Lo(ma3, b3, x, &sum_ma343, sum_b343, ma343, ma444, b343, b444);
}
inline void Store343_444Hi(const __m256i ma3[3], const __m256i b3[2],
const ptrdiff_t x, uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_ma343, sum_b343[2];
Store343_444Hi(ma3, b3, x, &sum_ma343, sum_b343, ma343, ma444, b343, b444);
}
// Don't combine the following 2 functions, which would be slower.
inline void Store343_444(const __m256i ma3[3], const __m256i b3[6],
const ptrdiff_t x, __m256i* const sum_ma343_lo,
__m256i* const sum_ma343_hi,
__m256i* const sum_ma444_lo,
__m256i* const sum_ma444_hi, __m256i sum_b343_lo[2],
__m256i sum_b343_hi[2], __m256i sum_b444_lo[2],
__m256i sum_b444_hi[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_mat343[2], sum_mat444[2];
const __m256i sum_ma111_lo = Sum3WLo16(ma3);
sum_mat444[0] = _mm256_slli_epi16(sum_ma111_lo, 2);
const __m256i sum333_lo = _mm256_sub_epi16(sum_mat444[0], sum_ma111_lo);
sum_mat343[0] = VaddwLo8(sum333_lo, ma3[1]);
Store343_444(b3, x, sum_b343_lo, sum_b444_lo, b343, b444);
const __m256i sum_ma111_hi = Sum3WHi16(ma3);
sum_mat444[1] = _mm256_slli_epi16(sum_ma111_hi, 2);
*sum_ma444_lo = _mm256_permute2x128_si256(sum_mat444[0], sum_mat444[1], 0x20);
*sum_ma444_hi = _mm256_permute2x128_si256(sum_mat444[0], sum_mat444[1], 0x31);
StoreAligned32(ma444 + x + 0, *sum_ma444_lo);
StoreAligned32(ma444 + x + 16, *sum_ma444_hi);
const __m256i sum333_hi = _mm256_sub_epi16(sum_mat444[1], sum_ma111_hi);
sum_mat343[1] = VaddwHi8(sum333_hi, ma3[1]);
*sum_ma343_lo = _mm256_permute2x128_si256(sum_mat343[0], sum_mat343[1], 0x20);
*sum_ma343_hi = _mm256_permute2x128_si256(sum_mat343[0], sum_mat343[1], 0x31);
StoreAligned32(ma343 + x + 0, *sum_ma343_lo);
StoreAligned32(ma343 + x + 16, *sum_ma343_hi);
Store343_444(b3 + 3, x + 16, sum_b343_hi, sum_b444_hi, b343, b444);
}
inline void Store343_444(const __m256i ma3[3], const __m256i b3[6],
const ptrdiff_t x, __m256i* const sum_ma343_lo,
__m256i* const sum_ma343_hi, __m256i sum_b343_lo[2],
__m256i sum_b343_hi[2], uint16_t* const ma343,
uint16_t* const ma444, uint32_t* const b343,
uint32_t* const b444) {
__m256i sum_ma444[2], sum_b444[2], sum_mat343[2];
const __m256i sum_ma111_lo = Sum3WLo16(ma3);
sum_ma444[0] = _mm256_slli_epi16(sum_ma111_lo, 2);
const __m256i sum333_lo = _mm256_sub_epi16(sum_ma444[0], sum_ma111_lo);
sum_mat343[0] = VaddwLo8(sum333_lo, ma3[1]);
Store343_444(b3, x, sum_b343_lo, sum_b444, b343, b444);
const __m256i sum_ma111_hi = Sum3WHi16(ma3);
sum_ma444[1] = _mm256_slli_epi16(sum_ma111_hi, 2);
StoreAligned64_ma(ma444 + x, sum_ma444);
const __m256i sum333_hi = _mm256_sub_epi16(sum_ma444[1], sum_ma111_hi);
sum_mat343[1] = VaddwHi8(sum333_hi, ma3[1]);
*sum_ma343_lo = _mm256_permute2x128_si256(sum_mat343[0], sum_mat343[1], 0x20);
*sum_ma343_hi = _mm256_permute2x128_si256(sum_mat343[0], sum_mat343[1], 0x31);
StoreAligned32(ma343 + x + 0, *sum_ma343_lo);
StoreAligned32(ma343 + x + 16, *sum_ma343_hi);
Store343_444(b3 + 3, x + 16, sum_b343_hi, sum_b444, b343, b444);
}
inline void PermuteB(const __m256i t[4], __m256i b[7]) {
// Input:
// 0 1 2 3 // b[0]
// 4 5 6 7 // b[1]
// 8 9 10 11 24 25 26 27 // t[0]
// 12 13 14 15 28 29 30 31 // t[1]
// 16 17 18 19 32 33 34 35 // t[2]
// 20 21 22 23 36 37 38 39 // t[3]
// Output:
// 0 1 2 3 8 9 10 11 // b[0]
// 4 5 6 7 12 13 14 15 // b[1]
// 8 9 10 11 16 17 18 19 // b[2]
// 16 17 18 19 24 25 26 27 // b[3]
// 20 21 22 23 28 29 30 31 // b[4]
// 24 25 26 27 32 33 34 35 // b[5]
// 20 21 22 23 36 37 38 39 // b[6]
b[0] = _mm256_permute2x128_si256(b[0], t[0], 0x21);
b[1] = _mm256_permute2x128_si256(b[1], t[1], 0x21);
b[2] = _mm256_permute2x128_si256(t[0], t[2], 0x20);
b[3] = _mm256_permute2x128_si256(t[2], t[0], 0x30);
b[4] = _mm256_permute2x128_si256(t[3], t[1], 0x30);
b[5] = _mm256_permute2x128_si256(t[0], t[2], 0x31);
b[6] = t[3];
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess5Lo(
const __m128i s[2][2], const uint32_t scale, uint16_t* const sum5[5],
uint32_t* const square_sum5[5], __m128i sq[2][4], __m128i* const ma,
__m128i b[2]) {
__m128i s5[2][5], sq5[5][2];
Square(s[0][1], sq[0] + 2);
Square(s[1][1], sq[1] + 2);
s5[0][3] = Sum5Horizontal16(s[0]);
StoreAligned16(sum5[3], s5[0][3]);
s5[0][4] = Sum5Horizontal16(s[1]);
StoreAligned16(sum5[4], s5[0][4]);
Sum5Horizontal32(sq[0], sq5[3]);
StoreAligned32U32(square_sum5[3], sq5[3]);
Sum5Horizontal32(sq[1], sq5[4]);
StoreAligned32U32(square_sum5[4], sq5[4]);
LoadAligned16x3U16(sum5, 0, s5[0]);
LoadAligned32x3U32(square_sum5, 0, sq5);
CalculateIntermediate5(s5[0], sq5, scale, ma, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess5(
const uint16_t* const src0, const uint16_t* const src1,
const ptrdiff_t over_read_in_bytes, const ptrdiff_t sum_width,
const ptrdiff_t x, const uint32_t scale, uint16_t* const sum5[5],
uint32_t* const square_sum5[5], __m256i sq[2][8], __m256i ma[3],
__m256i b[3]) {
__m256i s[2], s5[2][5], sq5[5][2], sum[2], index[2], t[4];
s[0] = LoadUnaligned32Msan(src0 + 8, over_read_in_bytes + 16);
s[1] = LoadUnaligned32Msan(src1 + 8, over_read_in_bytes + 16);
Square(s[0], sq[0] + 2);
Square(s[1], sq[1] + 2);
sq[0][0] = _mm256_permute2x128_si256(sq[0][0], sq[0][2], 0x21);
sq[0][1] = _mm256_permute2x128_si256(sq[0][1], sq[0][3], 0x21);
sq[1][0] = _mm256_permute2x128_si256(sq[1][0], sq[1][2], 0x21);
sq[1][1] = _mm256_permute2x128_si256(sq[1][1], sq[1][3], 0x21);
s5[0][3] = Sum5Horizontal16(src0 + 0, over_read_in_bytes + 0);
s5[1][3] = Sum5Horizontal16(src0 + 16, over_read_in_bytes + 32);
s5[0][4] = Sum5Horizontal16(src1 + 0, over_read_in_bytes + 0);
s5[1][4] = Sum5Horizontal16(src1 + 16, over_read_in_bytes + 32);
StoreAligned32(sum5[3] + x + 0, s5[0][3]);
StoreAligned32(sum5[3] + x + 16, s5[1][3]);
StoreAligned32(sum5[4] + x + 0, s5[0][4]);
StoreAligned32(sum5[4] + x + 16, s5[1][4]);
Sum5Horizontal32(sq[0], sq5[3]);
StoreAligned64(square_sum5[3] + x, sq5[3]);
Sum5Horizontal32(sq[1], sq5[4]);
StoreAligned64(square_sum5[4] + x, sq5[4]);
LoadAligned32x3U16(sum5, x, s5[0]);
LoadAligned64x3U32(square_sum5, x, sq5);
CalculateSumAndIndex5(s5[0], sq5, scale, &sum[0], &index[0]);
s[0] = LoadUnaligned32Msan(src0 + 24, over_read_in_bytes + 48);
s[1] = LoadUnaligned32Msan(src1 + 24, over_read_in_bytes + 48);
Square(s[0], sq[0] + 6);
Square(s[1], sq[1] + 6);
sq[0][4] = _mm256_permute2x128_si256(sq[0][2], sq[0][6], 0x21);
sq[0][5] = _mm256_permute2x128_si256(sq[0][3], sq[0][7], 0x21);
sq[1][4] = _mm256_permute2x128_si256(sq[1][2], sq[1][6], 0x21);
sq[1][5] = _mm256_permute2x128_si256(sq[1][3], sq[1][7], 0x21);
Sum5Horizontal32(sq[0] + 4, sq5[3]);
StoreAligned64(square_sum5[3] + x + 16, sq5[3]);
Sum5Horizontal32(sq[1] + 4, sq5[4]);
StoreAligned64(square_sum5[4] + x + 16, sq5[4]);
LoadAligned32x3U16Msan(sum5, x + 16, sum_width, s5[1]);
LoadAligned64x3U32Msan(square_sum5, x + 16, sum_width, sq5);
CalculateSumAndIndex5(s5[1], sq5, scale, &sum[1], &index[1]);
CalculateIntermediate<25>(sum, index, ma, t, t + 2);
PermuteB(t, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess5LastRowLo(
const __m128i s[2], const uint32_t scale, const uint16_t* const sum5[5],
const uint32_t* const square_sum5[5], __m128i sq[4], __m128i* const ma,
__m128i b[2]) {
__m128i s5[5], sq5[5][2];
Square(s[1], sq + 2);
s5[3] = s5[4] = Sum5Horizontal16(s);
Sum5Horizontal32(sq, sq5[3]);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
LoadAligned16x3U16(sum5, 0, s5);
LoadAligned32x3U32(square_sum5, 0, sq5);
CalculateIntermediate5(s5, sq5, scale, ma, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess5LastRow(
const uint16_t* const src, const ptrdiff_t over_read_in_bytes,
const ptrdiff_t sum_width, const ptrdiff_t x, const uint32_t scale,
const uint16_t* const sum5[5], const uint32_t* const square_sum5[5],
__m256i sq[3], __m256i ma[3], __m256i b[3]) {
const __m256i s0 = LoadUnaligned32Msan(src + 8, over_read_in_bytes + 16);
__m256i s5[2][5], sq5[5][2], sum[2], index[2], t[4];
Square(s0, sq + 2);
sq[0] = _mm256_permute2x128_si256(sq[0], sq[2], 0x21);
sq[1] = _mm256_permute2x128_si256(sq[1], sq[3], 0x21);
s5[0][3] = Sum5Horizontal16(src + 0, over_read_in_bytes + 0);
s5[1][3] = Sum5Horizontal16(src + 16, over_read_in_bytes + 32);
s5[0][4] = s5[0][3];
s5[1][4] = s5[1][3];
Sum5Horizontal32(sq, sq5[3]);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
LoadAligned32x3U16(sum5, x, s5[0]);
LoadAligned64x3U32(square_sum5, x, sq5);
CalculateSumAndIndex5(s5[0], sq5, scale, &sum[0], &index[0]);
const __m256i s1 = LoadUnaligned32Msan(src + 24, over_read_in_bytes + 48);
Square(s1, sq + 6);
sq[4] = _mm256_permute2x128_si256(sq[2], sq[6], 0x21);
sq[5] = _mm256_permute2x128_si256(sq[3], sq[7], 0x21);
Sum5Horizontal32(sq + 4, sq5[3]);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
LoadAligned32x3U16Msan(sum5, x + 16, sum_width, s5[1]);
LoadAligned64x3U32Msan(square_sum5, x + 16, sum_width, sq5);
CalculateSumAndIndex5(s5[1], sq5, scale, &sum[1], &index[1]);
CalculateIntermediate<25>(sum, index, ma, t, t + 2);
PermuteB(t, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess3Lo(
const __m128i s[2], const uint32_t scale, uint16_t* const sum3[3],
uint32_t* const square_sum3[3], __m128i sq[4], __m128i* const ma,
__m128i b[2]) {
__m128i s3[3], sq3[3][2];
Square(s[1], sq + 2);
s3[2] = Sum3Horizontal16(s);
StoreAligned16(sum3[2], s3[2]);
Sum3Horizontal32(sq, sq3[2]);
StoreAligned32U32(square_sum3[2], sq3[2]);
LoadAligned16x2U16(sum3, 0, s3);
LoadAligned32x2U32(square_sum3, 0, sq3);
CalculateIntermediate3(s3, sq3, scale, ma, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess3(
const uint16_t* const src, const ptrdiff_t over_read_in_bytes,
const ptrdiff_t x, const ptrdiff_t sum_width, const uint32_t scale,
uint16_t* const sum3[3], uint32_t* const square_sum3[3], __m256i sq[8],
__m256i ma[3], __m256i b[7]) {
__m256i s[2], s3[4], sq3[3][2], sum[2], index[2], t[4];
s[0] = LoadUnaligned32Msan(src + 8, over_read_in_bytes + 16);
s[1] = LoadUnaligned32Msan(src + 24, over_read_in_bytes + 48);
Square(s[0], sq + 2);
sq[0] = _mm256_permute2x128_si256(sq[0], sq[2], 0x21);
sq[1] = _mm256_permute2x128_si256(sq[1], sq[3], 0x21);
s3[2] = Sum3Horizontal16(src, over_read_in_bytes);
s3[3] = Sum3Horizontal16(src + 16, over_read_in_bytes + 32);
StoreAligned64(sum3[2] + x, s3 + 2);
Sum3Horizontal32(sq + 0, sq3[2]);
StoreAligned64(square_sum3[2] + x, sq3[2]);
LoadAligned32x2U16(sum3, x, s3);
LoadAligned64x2U32(square_sum3, x, sq3);
CalculateSumAndIndex3(s3, sq3, scale, &sum[0], &index[0]);
Square(s[1], sq + 6);
sq[4] = _mm256_permute2x128_si256(sq[2], sq[6], 0x21);
sq[5] = _mm256_permute2x128_si256(sq[3], sq[7], 0x21);
Sum3Horizontal32(sq + 4, sq3[2]);
StoreAligned64(square_sum3[2] + x + 16, sq3[2]);
LoadAligned32x2U16Msan(sum3, x + 16, sum_width, s3 + 1);
LoadAligned64x2U32Msan(square_sum3, x + 16, sum_width, sq3);
CalculateSumAndIndex3(s3 + 1, sq3, scale, &sum[1], &index[1]);
CalculateIntermediate<9>(sum, index, ma, t, t + 2);
PermuteB(t, b);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcessLo(
const __m128i s[2][4], const uint16_t scales[2], uint16_t* const sum3[4],
uint16_t* const sum5[5], uint32_t* const square_sum3[4],
uint32_t* const square_sum5[5], __m128i sq[2][8], __m128i ma3[2][3],
__m128i b3[2][10], __m128i* const ma5, __m128i b5[2]) {
__m128i s3[4], s5[5], sq3[4][2], sq5[5][2], sum[2], index[2];
Square(s[0][1], sq[0] + 2);
Square(s[1][1], sq[1] + 2);
SumHorizontal16(s[0], &s3[2], &s5[3]);
SumHorizontal16(s[1], &s3[3], &s5[4]);
StoreAligned16(sum3[2], s3[2]);
StoreAligned16(sum3[3], s3[3]);
StoreAligned16(sum5[3], s5[3]);
StoreAligned16(sum5[4], s5[4]);
SumHorizontal32(sq[0], &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
StoreAligned32U32(square_sum3[2], sq3[2]);
StoreAligned32U32(square_sum5[3], sq5[3]);
SumHorizontal32(sq[1], &sq3[3][0], &sq3[3][1], &sq5[4][0], &sq5[4][1]);
StoreAligned32U32(square_sum3[3], sq3[3]);
StoreAligned32U32(square_sum5[4], sq5[4]);
LoadAligned16x2U16(sum3, 0, s3);
LoadAligned32x2U32(square_sum3, 0, sq3);
LoadAligned16x3U16(sum5, 0, s5);
LoadAligned32x3U32(square_sum5, 0, sq5);
CalculateSumAndIndex3(s3 + 0, sq3 + 0, scales[1], &sum[0], &index[0]);
CalculateSumAndIndex3(s3 + 1, sq3 + 1, scales[1], &sum[1], &index[1]);
CalculateIntermediate(sum, index, &ma3[0][0], b3[0], b3[1]);
ma3[1][0] = _mm_srli_si128(ma3[0][0], 8);
CalculateIntermediate5(s5, sq5, scales[0], ma5, b5);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcess(
const uint16_t* const src0, const uint16_t* const src1,
const ptrdiff_t over_read_in_bytes, const ptrdiff_t x,
const uint16_t scales[2], uint16_t* const sum3[4], uint16_t* const sum5[5],
uint32_t* const square_sum3[4], uint32_t* const square_sum5[5],
const ptrdiff_t sum_width, __m256i sq[2][8], __m256i ma3[2][3],
__m256i b3[2][7], __m256i ma5[3], __m256i b5[5]) {
__m256i s[2], s3[2][4], s5[2][5], sq3[4][2], sq5[5][2], sum_3[2][2],
index_3[2][2], sum_5[2], index_5[2], t[4];
s[0] = LoadUnaligned32Msan(src0 + 8, over_read_in_bytes + 16);
s[1] = LoadUnaligned32Msan(src1 + 8, over_read_in_bytes + 16);
Square(s[0], sq[0] + 2);
Square(s[1], sq[1] + 2);
sq[0][0] = _mm256_permute2x128_si256(sq[0][0], sq[0][2], 0x21);
sq[0][1] = _mm256_permute2x128_si256(sq[0][1], sq[0][3], 0x21);
sq[1][0] = _mm256_permute2x128_si256(sq[1][0], sq[1][2], 0x21);
sq[1][1] = _mm256_permute2x128_si256(sq[1][1], sq[1][3], 0x21);
SumHorizontal16(src0, over_read_in_bytes, &s3[0][2], &s3[1][2], &s5[0][3],
&s5[1][3]);
SumHorizontal16(src1, over_read_in_bytes, &s3[0][3], &s3[1][3], &s5[0][4],
&s5[1][4]);
StoreAligned32(sum3[2] + x + 0, s3[0][2]);
StoreAligned32(sum3[2] + x + 16, s3[1][2]);
StoreAligned32(sum3[3] + x + 0, s3[0][3]);
StoreAligned32(sum3[3] + x + 16, s3[1][3]);
StoreAligned32(sum5[3] + x + 0, s5[0][3]);
StoreAligned32(sum5[3] + x + 16, s5[1][3]);
StoreAligned32(sum5[4] + x + 0, s5[0][4]);
StoreAligned32(sum5[4] + x + 16, s5[1][4]);
SumHorizontal32(sq[0], &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
SumHorizontal32(sq[1], &sq3[3][0], &sq3[3][1], &sq5[4][0], &sq5[4][1]);
StoreAligned64(square_sum3[2] + x, sq3[2]);
StoreAligned64(square_sum5[3] + x, sq5[3]);
StoreAligned64(square_sum3[3] + x, sq3[3]);
StoreAligned64(square_sum5[4] + x, sq5[4]);
LoadAligned32x2U16(sum3, x, s3[0]);
LoadAligned64x2U32(square_sum3, x, sq3);
CalculateSumAndIndex3(s3[0], sq3, scales[1], &sum_3[0][0], &index_3[0][0]);
CalculateSumAndIndex3(s3[0] + 1, sq3 + 1, scales[1], &sum_3[1][0],
&index_3[1][0]);
LoadAligned32x3U16(sum5, x, s5[0]);
LoadAligned64x3U32(square_sum5, x, sq5);
CalculateSumAndIndex5(s5[0], sq5, scales[0], &sum_5[0], &index_5[0]);
s[0] = LoadUnaligned32Msan(src0 + 24, over_read_in_bytes + 48);
s[1] = LoadUnaligned32Msan(src1 + 24, over_read_in_bytes + 48);
Square(s[0], sq[0] + 6);
Square(s[1], sq[1] + 6);
sq[0][4] = _mm256_permute2x128_si256(sq[0][2], sq[0][6], 0x21);
sq[0][5] = _mm256_permute2x128_si256(sq[0][3], sq[0][7], 0x21);
sq[1][4] = _mm256_permute2x128_si256(sq[1][2], sq[1][6], 0x21);
sq[1][5] = _mm256_permute2x128_si256(sq[1][3], sq[1][7], 0x21);
SumHorizontal32(sq[0] + 4, &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
SumHorizontal32(sq[1] + 4, &sq3[3][0], &sq3[3][1], &sq5[4][0], &sq5[4][1]);
StoreAligned64(square_sum3[2] + x + 16, sq3[2]);
StoreAligned64(square_sum5[3] + x + 16, sq5[3]);
StoreAligned64(square_sum3[3] + x + 16, sq3[3]);
StoreAligned64(square_sum5[4] + x + 16, sq5[4]);
LoadAligned32x2U16Msan(sum3, x + 16, sum_width, s3[1]);
LoadAligned64x2U32Msan(square_sum3, x + 16, sum_width, sq3);
CalculateSumAndIndex3(s3[1], sq3, scales[1], &sum_3[0][1], &index_3[0][1]);
CalculateSumAndIndex3(s3[1] + 1, sq3 + 1, scales[1], &sum_3[1][1],
&index_3[1][1]);
CalculateIntermediate<9>(sum_3[0], index_3[0], ma3[0], t, t + 2);
PermuteB(t, b3[0]);
CalculateIntermediate<9>(sum_3[1], index_3[1], ma3[1], t, t + 2);
PermuteB(t, b3[1]);
LoadAligned32x3U16Msan(sum5, x + 16, sum_width, s5[1]);
LoadAligned64x3U32Msan(square_sum5, x + 16, sum_width, sq5);
CalculateSumAndIndex5(s5[1], sq5, scales[0], &sum_5[1], &index_5[1]);
CalculateIntermediate<25>(sum_5, index_5, ma5, t, t + 2);
PermuteB(t, b5);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcessLastRowLo(
const __m128i s[2], const uint16_t scales[2], const uint16_t* const sum3[4],
const uint16_t* const sum5[5], const uint32_t* const square_sum3[4],
const uint32_t* const square_sum5[5], __m128i sq[4], __m128i* const ma3,
__m128i* const ma5, __m128i b3[2], __m128i b5[2]) {
__m128i s3[3], s5[5], sq3[3][2], sq5[5][2];
Square(s[1], sq + 2);
SumHorizontal16(s, &s3[2], &s5[3]);
SumHorizontal32(sq, &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
LoadAligned16x3U16(sum5, 0, s5);
s5[4] = s5[3];
LoadAligned32x3U32(square_sum5, 0, sq5);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
CalculateIntermediate5(s5, sq5, scales[0], ma5, b5);
LoadAligned16x2U16(sum3, 0, s3);
LoadAligned32x2U32(square_sum3, 0, sq3);
CalculateIntermediate3(s3, sq3, scales[1], ma3, b3);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPreProcessLastRow(
const uint16_t* const src, const ptrdiff_t over_read_in_bytes,
const ptrdiff_t sum_width, const ptrdiff_t x, const uint16_t scales[2],
const uint16_t* const sum3[4], const uint16_t* const sum5[5],
const uint32_t* const square_sum3[4], const uint32_t* const square_sum5[5],
__m256i sq[6], __m256i ma3[2], __m256i ma5[2], __m256i b3[5],
__m256i b5[5]) {
const __m256i s0 = LoadUnaligned32Msan(src + 8, over_read_in_bytes + 16);
__m256i s3[2][3], s5[2][5], sq3[4][2], sq5[5][2], sum_3[2], index_3[2],
sum_5[2], index_5[2], t[4];
Square(s0, sq + 2);
sq[0] = _mm256_permute2x128_si256(sq[0], sq[2], 0x21);
sq[1] = _mm256_permute2x128_si256(sq[1], sq[3], 0x21);
SumHorizontal16(src, over_read_in_bytes, &s3[0][2], &s3[1][2], &s5[0][3],
&s5[1][3]);
SumHorizontal32(sq, &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
LoadAligned32x2U16(sum3, x, s3[0]);
LoadAligned64x2U32(square_sum3, x, sq3);
CalculateSumAndIndex3(s3[0], sq3, scales[1], &sum_3[0], &index_3[0]);
LoadAligned32x3U16(sum5, x, s5[0]);
s5[0][4] = s5[0][3];
LoadAligned64x3U32(square_sum5, x, sq5);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
CalculateSumAndIndex5(s5[0], sq5, scales[0], &sum_5[0], &index_5[0]);
const __m256i s1 = LoadUnaligned32Msan(src + 24, over_read_in_bytes + 48);
Square(s1, sq + 6);
sq[4] = _mm256_permute2x128_si256(sq[2], sq[6], 0x21);
sq[5] = _mm256_permute2x128_si256(sq[3], sq[7], 0x21);
SumHorizontal32(sq + 4, &sq3[2][0], &sq3[2][1], &sq5[3][0], &sq5[3][1]);
LoadAligned32x2U16Msan(sum3, x + 16, sum_width, s3[1]);
LoadAligned64x2U32Msan(square_sum3, x + 16, sum_width, sq3);
CalculateSumAndIndex3(s3[1], sq3, scales[1], &sum_3[1], &index_3[1]);
CalculateIntermediate<9>(sum_3, index_3, ma3, t, t + 2);
PermuteB(t, b3);
LoadAligned32x3U16Msan(sum5, x + 16, sum_width, s5[1]);
s5[1][4] = s5[1][3];
LoadAligned64x3U32Msan(square_sum5, x + 16, sum_width, sq5);
sq5[4][0] = sq5[3][0];
sq5[4][1] = sq5[3][1];
CalculateSumAndIndex5(s5[1], sq5, scales[0], &sum_5[1], &index_5[1]);
CalculateIntermediate<25>(sum_5, index_5, ma5, t, t + 2);
PermuteB(t, b5);
}
inline void BoxSumFilterPreProcess5(const uint16_t* const src0,
const uint16_t* const src1, const int width,
const uint32_t scale,
uint16_t* const sum5[5],
uint32_t* const square_sum5[5],
const ptrdiff_t sum_width, uint16_t* ma565,
uint32_t* b565) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2][2], ma0, sq_128[2][4], b0[2];
__m256i mas[3], sq[2][8], bs[10];
s[0][0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[0][1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
s[1][0] = LoadUnaligned16Msan(src1 + 0, overread_in_bytes + 0);
s[1][1] = LoadUnaligned16Msan(src1 + 8, overread_in_bytes + 16);
Square(s[0][0], sq_128[0]);
Square(s[1][0], sq_128[1]);
BoxFilterPreProcess5Lo(s, scale, sum5, square_sum5, sq_128, &ma0, b0);
sq[0][0] = SetrM128i(sq_128[0][2], sq_128[0][2]);
sq[0][1] = SetrM128i(sq_128[0][3], sq_128[0][3]);
sq[1][0] = SetrM128i(sq_128[1][2], sq_128[1][2]);
sq[1][1] = SetrM128i(sq_128[1][3], sq_128[1][3]);
mas[0] = SetrM128i(ma0, ma0);
bs[0] = SetrM128i(b0[0], b0[0]);
bs[1] = SetrM128i(b0[1], b0[1]);
int x = 0;
do {
__m256i ma5[3], ma[2], b[4];
BoxFilterPreProcess5(
src0 + x + 8, src1 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), sum_width,
x + 8, scale, sum5, square_sum5, sq, mas, bs);
Prepare3_8(mas, ma5);
ma[0] = Sum565Lo(ma5);
ma[1] = Sum565Hi(ma5);
StoreAligned64_ma(ma565, ma);
Sum565(bs + 0, b + 0);
Sum565(bs + 3, b + 2);
StoreAligned64(b565, b + 0);
StoreAligned64(b565 + 16, b + 2);
sq[0][0] = sq[0][6];
sq[0][1] = sq[0][7];
sq[1][0] = sq[1][6];
sq[1][1] = sq[1][7];
mas[0] = mas[2];
bs[0] = bs[5];
bs[1] = bs[6];
ma565 += 32;
b565 += 32;
x += 32;
} while (x < width);
}
template <bool calculate444>
LIBGAV1_ALWAYS_INLINE void BoxSumFilterPreProcess3(
const uint16_t* const src, const int width, const uint32_t scale,
uint16_t* const sum3[3], uint32_t* const square_sum3[3],
const ptrdiff_t sum_width, uint16_t* ma343, uint16_t* ma444, uint32_t* b343,
uint32_t* b444) {
const ptrdiff_t overread_in_bytes_128 =
kOverreadInBytesPass2_128 - sizeof(*src) * width;
__m128i s[2], ma0, sq_128[4], b0[2];
__m256i mas[3], sq[8], bs[7];
s[0] = LoadUnaligned16Msan(src + 0, overread_in_bytes_128 + 0);
s[1] = LoadUnaligned16Msan(src + 8, overread_in_bytes_128 + 16);
Square(s[0], sq_128);
BoxFilterPreProcess3Lo(s, scale, sum3, square_sum3, sq_128, &ma0, b0);
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
mas[0] = SetrM128i(ma0, ma0);
bs[0] = SetrM128i(b0[0], b0[0]);
bs[1] = SetrM128i(b0[1], b0[1]);
int x = 0;
do {
__m256i ma3[3];
BoxFilterPreProcess3(
src + x + 8, kOverreadInBytesPass2_256 + sizeof(*src) * (x + 8 - width),
x + 8, sum_width, scale, sum3, square_sum3, sq, mas, bs);
Prepare3_8(mas, ma3);
if (calculate444) { // NOLINT(readability-simplify-boolean-expr)
Store343_444Lo(ma3, bs + 0, 0, ma343, ma444, b343, b444);
Store343_444Hi(ma3, bs + 3, kMaStoreOffset, ma343, ma444, b343, b444);
ma444 += 32;
b444 += 32;
} else {
__m256i ma[2], b[4];
ma[0] = Sum343Lo(ma3);
ma[1] = Sum343Hi(ma3);
StoreAligned64_ma(ma343, ma);
Sum343(bs + 0, b + 0);
Sum343(bs + 3, b + 2);
StoreAligned64(b343 + 0, b + 0);
StoreAligned64(b343 + 16, b + 2);
}
sq[0] = sq[6];
sq[1] = sq[7];
mas[0] = mas[2];
bs[0] = bs[5];
bs[1] = bs[6];
ma343 += 32;
b343 += 32;
x += 32;
} while (x < width);
}
inline void BoxSumFilterPreProcess(
const uint16_t* const src0, const uint16_t* const src1, const int width,
const uint16_t scales[2], uint16_t* const sum3[4], uint16_t* const sum5[5],
uint32_t* const square_sum3[4], uint32_t* const square_sum5[5],
const ptrdiff_t sum_width, uint16_t* const ma343[4], uint16_t* const ma444,
uint16_t* ma565, uint32_t* const b343[4], uint32_t* const b444,
uint32_t* b565) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2][4], ma3_128[2][3], ma5_128[3], sq_128[2][8], b3_128[2][10],
b5_128[10];
__m256i ma3[2][3], ma5[3], sq[2][8], b3[2][7], b5[7];
s[0][0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[0][1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
s[1][0] = LoadUnaligned16Msan(src1 + 0, overread_in_bytes + 0);
s[1][1] = LoadUnaligned16Msan(src1 + 8, overread_in_bytes + 16);
Square(s[0][0], sq_128[0]);
Square(s[1][0], sq_128[1]);
BoxFilterPreProcessLo(s, scales, sum3, sum5, square_sum3, square_sum5, sq_128,
ma3_128, b3_128, &ma5_128[0], b5_128);
sq[0][0] = SetrM128i(sq_128[0][2], sq_128[0][2]);
sq[0][1] = SetrM128i(sq_128[0][3], sq_128[0][3]);
sq[1][0] = SetrM128i(sq_128[1][2], sq_128[1][2]);
sq[1][1] = SetrM128i(sq_128[1][3], sq_128[1][3]);
ma3[0][0] = SetrM128i(ma3_128[0][0], ma3_128[0][0]);
ma3[1][0] = SetrM128i(ma3_128[1][0], ma3_128[1][0]);
ma5[0] = SetrM128i(ma5_128[0], ma5_128[0]);
b3[0][0] = SetrM128i(b3_128[0][0], b3_128[0][0]);
b3[0][1] = SetrM128i(b3_128[0][1], b3_128[0][1]);
b3[1][0] = SetrM128i(b3_128[1][0], b3_128[1][0]);
b3[1][1] = SetrM128i(b3_128[1][1], b3_128[1][1]);
b5[0] = SetrM128i(b5_128[0], b5_128[0]);
b5[1] = SetrM128i(b5_128[1], b5_128[1]);
int x = 0;
do {
__m256i ma[2], b[4], ma3x[3], ma5x[3];
BoxFilterPreProcess(
src0 + x + 8, src1 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), x + 8,
scales, sum3, sum5, square_sum3, square_sum5, sum_width, sq, ma3, b3,
ma5, b5);
Prepare3_8(ma3[0], ma3x);
ma[0] = Sum343Lo(ma3x);
ma[1] = Sum343Hi(ma3x);
StoreAligned64_ma(ma343[0] + x, ma);
Sum343(b3[0], b);
Sum343(b3[0] + 3, b + 2);
StoreAligned64(b343[0] + x, b);
StoreAligned64(b343[0] + x + 16, b + 2);
Prepare3_8(ma3[1], ma3x);
Store343_444Lo(ma3x, b3[1], x, ma343[1], ma444, b343[1], b444);
Store343_444Hi(ma3x, b3[1] + 3, x + kMaStoreOffset, ma343[1], ma444,
b343[1], b444);
Prepare3_8(ma5, ma5x);
ma[0] = Sum565Lo(ma5x);
ma[1] = Sum565Hi(ma5x);
StoreAligned64_ma(ma565, ma);
Sum565(b5, b);
StoreAligned64(b565, b);
Sum565(b5 + 3, b);
StoreAligned64(b565 + 16, b);
sq[0][0] = sq[0][6];
sq[0][1] = sq[0][7];
sq[1][0] = sq[1][6];
sq[1][1] = sq[1][7];
ma3[0][0] = ma3[0][2];
ma3[1][0] = ma3[1][2];
ma5[0] = ma5[2];
b3[0][0] = b3[0][5];
b3[0][1] = b3[0][6];
b3[1][0] = b3[1][5];
b3[1][1] = b3[1][6];
b5[0] = b5[5];
b5[1] = b5[6];
ma565 += 32;
b565 += 32;
x += 32;
} while (x < width);
}
template <int shift>
inline __m256i FilterOutput(const __m256i ma_x_src, const __m256i b) {
// ma: 255 * 32 = 8160 (13 bits)
// b: 65088 * 32 = 2082816 (21 bits)
// v: b - ma * 255 (22 bits)
const __m256i v = _mm256_sub_epi32(b, ma_x_src);
// kSgrProjSgrBits = 8
// kSgrProjRestoreBits = 4
// shift = 4 or 5
// v >> 8 or 9 (13 bits)
return VrshrS32(v, kSgrProjSgrBits + shift - kSgrProjRestoreBits);
}
template <int shift>
inline __m256i CalculateFilteredOutput(const __m256i src, const __m256i ma,
const __m256i b[2]) {
const __m256i ma_x_src_lo = VmullLo16(ma, src);
const __m256i ma_x_src_hi = VmullHi16(ma, src);
const __m256i dst_lo = FilterOutput<shift>(ma_x_src_lo, b[0]);
const __m256i dst_hi = FilterOutput<shift>(ma_x_src_hi, b[1]);
return _mm256_packs_epi32(dst_lo, dst_hi); // 13 bits
}
inline __m256i CalculateFilteredOutputPass1(const __m256i src,
const __m256i ma[2],
const __m256i b[2][2]) {
const __m256i ma_sum = _mm256_add_epi16(ma[0], ma[1]);
__m256i b_sum[2];
b_sum[0] = _mm256_add_epi32(b[0][0], b[1][0]);
b_sum[1] = _mm256_add_epi32(b[0][1], b[1][1]);
return CalculateFilteredOutput<5>(src, ma_sum, b_sum);
}
inline __m256i CalculateFilteredOutputPass2(const __m256i src,
const __m256i ma[3],
const __m256i b[3][2]) {
const __m256i ma_sum = Sum3_16(ma);
__m256i b_sum[2];
Sum3_32(b, b_sum);
return CalculateFilteredOutput<5>(src, ma_sum, b_sum);
}
inline __m256i SelfGuidedFinal(const __m256i src, const __m256i v[2]) {
const __m256i v_lo =
VrshrS32(v[0], kSgrProjRestoreBits + kSgrProjPrecisionBits);
const __m256i v_hi =
VrshrS32(v[1], kSgrProjRestoreBits + kSgrProjPrecisionBits);
const __m256i vv = _mm256_packs_epi32(v_lo, v_hi);
return _mm256_add_epi16(src, vv);
}
inline __m256i SelfGuidedDoubleMultiplier(const __m256i src,
const __m256i filter[2], const int w0,
const int w2) {
__m256i v[2];
const __m256i w0_w2 =
_mm256_set1_epi32((w2 << 16) | static_cast<uint16_t>(w0));
const __m256i f_lo = _mm256_unpacklo_epi16(filter[0], filter[1]);
const __m256i f_hi = _mm256_unpackhi_epi16(filter[0], filter[1]);
v[0] = _mm256_madd_epi16(w0_w2, f_lo);
v[1] = _mm256_madd_epi16(w0_w2, f_hi);
return SelfGuidedFinal(src, v);
}
inline __m256i SelfGuidedSingleMultiplier(const __m256i src,
const __m256i filter, const int w0) {
// weight: -96 to 96 (Sgrproj_Xqd_Min/Max)
__m256i v[2];
v[0] = VmullNLo8(filter, w0);
v[1] = VmullNHi8(filter, w0);
return SelfGuidedFinal(src, v);
}
inline void ClipAndStore(uint16_t* const dst, const __m256i val) {
const __m256i val0 = _mm256_max_epi16(val, _mm256_setzero_si256());
const __m256i val1 = _mm256_min_epi16(val0, _mm256_set1_epi16(1023));
StoreUnaligned32(dst, val1);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPass1(
const uint16_t* const src, const uint16_t* const src0,
const uint16_t* const src1, const ptrdiff_t stride, uint16_t* const sum5[5],
uint32_t* const square_sum5[5], const int width, const ptrdiff_t sum_width,
const uint32_t scale, const int16_t w0, uint16_t* const ma565[2],
uint32_t* const b565[2], uint16_t* const dst) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2][2], ma0, sq_128[2][4], b0[2];
__m256i mas[3], sq[2][8], bs[7];
s[0][0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[0][1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
s[1][0] = LoadUnaligned16Msan(src1 + 0, overread_in_bytes + 0);
s[1][1] = LoadUnaligned16Msan(src1 + 8, overread_in_bytes + 16);
Square(s[0][0], sq_128[0]);
Square(s[1][0], sq_128[1]);
BoxFilterPreProcess5Lo(s, scale, sum5, square_sum5, sq_128, &ma0, b0);
sq[0][0] = SetrM128i(sq_128[0][2], sq_128[0][2]);
sq[0][1] = SetrM128i(sq_128[0][3], sq_128[0][3]);
sq[1][0] = SetrM128i(sq_128[1][2], sq_128[1][2]);
sq[1][1] = SetrM128i(sq_128[1][3], sq_128[1][3]);
mas[0] = SetrM128i(ma0, ma0);
bs[0] = SetrM128i(b0[0], b0[0]);
bs[1] = SetrM128i(b0[1], b0[1]);
int x = 0;
do {
__m256i ma5[3], ma[4], b[4][2];
BoxFilterPreProcess5(
src0 + x + 8, src1 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), sum_width,
x + 8, scale, sum5, square_sum5, sq, mas, bs);
Prepare3_8(mas, ma5);
ma[2] = Sum565Lo(ma5);
ma[3] = Sum565Hi(ma5);
ma[1] = _mm256_permute2x128_si256(ma[2], ma[3], 0x20);
ma[3] = _mm256_permute2x128_si256(ma[2], ma[3], 0x31);
StoreAligned32(ma565[1] + x + 0, ma[1]);
StoreAligned32(ma565[1] + x + 16, ma[3]);
Sum565(bs + 0, b[1]);
Sum565(bs + 3, b[3]);
StoreAligned64(b565[1] + x, b[1]);
StoreAligned64(b565[1] + x + 16, b[3]);
const __m256i sr0_lo = LoadUnaligned32(src + x + 0);
ma[0] = LoadAligned32(ma565[0] + x);
LoadAligned64(b565[0] + x, b[0]);
const __m256i p0 = CalculateFilteredOutputPass1(sr0_lo, ma, b);
const __m256i d0 = SelfGuidedSingleMultiplier(sr0_lo, p0, w0);
ClipAndStore(dst + x + 0, d0);
const __m256i sr0_hi = LoadUnaligned32(src + x + 16);
ma[2] = LoadAligned32(ma565[0] + x + 16);
LoadAligned64(b565[0] + x + 16, b[2]);
const __m256i p1 = CalculateFilteredOutputPass1(sr0_hi, ma + 2, b + 2);
const __m256i d1 = SelfGuidedSingleMultiplier(sr0_hi, p1, w0);
ClipAndStore(dst + x + 16, d1);
const __m256i sr1_lo = LoadUnaligned32(src + stride + x + 0);
const __m256i p10 = CalculateFilteredOutput<4>(sr1_lo, ma[1], b[1]);
const __m256i d10 = SelfGuidedSingleMultiplier(sr1_lo, p10, w0);
ClipAndStore(dst + stride + x + 0, d10);
const __m256i sr1_hi = LoadUnaligned32(src + stride + x + 16);
const __m256i p11 = CalculateFilteredOutput<4>(sr1_hi, ma[3], b[3]);
const __m256i d11 = SelfGuidedSingleMultiplier(sr1_hi, p11, w0);
ClipAndStore(dst + stride + x + 16, d11);
sq[0][0] = sq[0][6];
sq[0][1] = sq[0][7];
sq[1][0] = sq[1][6];
sq[1][1] = sq[1][7];
mas[0] = mas[2];
bs[0] = bs[5];
bs[1] = bs[6];
x += 32;
} while (x < width);
}
inline void BoxFilterPass1LastRow(
const uint16_t* const src, const uint16_t* const src0, const int width,
const ptrdiff_t sum_width, const uint32_t scale, const int16_t w0,
uint16_t* const sum5[5], uint32_t* const square_sum5[5], uint16_t* ma565,
uint32_t* b565, uint16_t* const dst) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2], ma0[2], sq_128[8], b0[6];
__m256i mas[3], sq[8], bs[7];
s[0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
Square(s[0], sq_128);
BoxFilterPreProcess5LastRowLo(s, scale, sum5, square_sum5, sq_128, &ma0[0],
b0);
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
mas[0] = SetrM128i(ma0[0], ma0[0]);
bs[0] = SetrM128i(b0[0], b0[0]);
bs[1] = SetrM128i(b0[1], b0[1]);
int x = 0;
do {
__m256i ma5[3], ma[4], b[4][2];
BoxFilterPreProcess5LastRow(
src0 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), sum_width,
x + 8, scale, sum5, square_sum5, sq, mas, bs);
Prepare3_8(mas, ma5);
ma[2] = Sum565Lo(ma5);
ma[3] = Sum565Hi(ma5);
Sum565(bs + 0, b[1]);
Sum565(bs + 3, b[3]);
const __m256i sr0_lo = LoadUnaligned32(src + x + 0);
ma[0] = LoadAligned32(ma565 + x);
ma[1] = _mm256_permute2x128_si256(ma[2], ma[3], 0x20);
LoadAligned64(b565 + x, b[0]);
const __m256i p0 = CalculateFilteredOutputPass1(sr0_lo, ma, b);
const __m256i d0 = SelfGuidedSingleMultiplier(sr0_lo, p0, w0);
ClipAndStore(dst + x + 0, d0);
const __m256i sr0_hi = LoadUnaligned32(src + x + 16);
ma[0] = LoadAligned32(ma565 + x + 16);
ma[1] = _mm256_permute2x128_si256(ma[2], ma[3], 0x31);
LoadAligned64(b565 + x + 16, b[2]);
const __m256i p1 = CalculateFilteredOutputPass1(sr0_hi, ma, b + 2);
const __m256i d1 = SelfGuidedSingleMultiplier(sr0_hi, p1, w0);
ClipAndStore(dst + x + 16, d1);
sq[0] = sq[6];
sq[1] = sq[7];
mas[0] = mas[2];
bs[0] = bs[5];
bs[1] = bs[6];
x += 32;
} while (x < width);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterPass2(
const uint16_t* const src, const uint16_t* const src0, const int width,
const ptrdiff_t sum_width, const uint32_t scale, const int16_t w0,
uint16_t* const sum3[3], uint32_t* const square_sum3[3],
uint16_t* const ma343[3], uint16_t* const ma444[2], uint32_t* const b343[3],
uint32_t* const b444[2], uint16_t* const dst) {
const ptrdiff_t overread_in_bytes_128 =
kOverreadInBytesPass2_128 - sizeof(*src0) * width;
__m128i s0[2], ma0, sq_128[4], b0[2];
__m256i mas[3], sq[8], bs[7];
s0[0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes_128 + 0);
s0[1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes_128 + 16);
Square(s0[0], sq_128);
BoxFilterPreProcess3Lo(s0, scale, sum3, square_sum3, sq_128, &ma0, b0);
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
mas[0] = SetrM128i(ma0, ma0);
bs[0] = SetrM128i(b0[0], b0[0]);
bs[1] = SetrM128i(b0[1], b0[1]);
int x = 0;
do {
__m256i ma[4], b[4][2], ma3[3];
BoxFilterPreProcess3(
src0 + x + 8,
kOverreadInBytesPass2_256 + sizeof(*src0) * (x + 8 - width), x + 8,
sum_width, scale, sum3, square_sum3, sq, mas, bs);
Prepare3_8(mas, ma3);
Store343_444(ma3, bs, x, &ma[2], &ma[3], b[2], b[3], ma343[2], ma444[1],
b343[2], b444[1]);
const __m256i sr_lo = LoadUnaligned32(src + x + 0);
const __m256i sr_hi = LoadUnaligned32(src + x + 16);
ma[0] = LoadAligned32(ma343[0] + x);
ma[1] = LoadAligned32(ma444[0] + x);
LoadAligned64(b343[0] + x, b[0]);
LoadAligned64(b444[0] + x, b[1]);
const __m256i p0 = CalculateFilteredOutputPass2(sr_lo, ma, b);
ma[1] = LoadAligned32(ma343[0] + x + 16);
ma[2] = LoadAligned32(ma444[0] + x + 16);
LoadAligned64(b343[0] + x + 16, b[1]);
LoadAligned64(b444[0] + x + 16, b[2]);
const __m256i p1 = CalculateFilteredOutputPass2(sr_hi, ma + 1, b + 1);
const __m256i d0 = SelfGuidedSingleMultiplier(sr_lo, p0, w0);
const __m256i d1 = SelfGuidedSingleMultiplier(sr_hi, p1, w0);
ClipAndStore(dst + x + 0, d0);
ClipAndStore(dst + x + 16, d1);
sq[0] = sq[6];
sq[1] = sq[7];
mas[0] = mas[2];
bs[0] = bs[5];
bs[1] = bs[6];
x += 32;
} while (x < width);
}
LIBGAV1_ALWAYS_INLINE void BoxFilter(
const uint16_t* const src, const uint16_t* const src0,
const uint16_t* const src1, const ptrdiff_t stride, const int width,
const uint16_t scales[2], const int16_t w0, const int16_t w2,
uint16_t* const sum3[4], uint16_t* const sum5[5],
uint32_t* const square_sum3[4], uint32_t* const square_sum5[5],
const ptrdiff_t sum_width, uint16_t* const ma343[4],
uint16_t* const ma444[3], uint16_t* const ma565[2], uint32_t* const b343[4],
uint32_t* const b444[3], uint32_t* const b565[2], uint16_t* const dst) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2][4], ma3_128[2][3], ma5_0, sq_128[2][8], b3_128[2][10], b5_128[2];
__m256i ma3[2][3], ma5[3], sq[2][8], b3[2][7], b5[7];
s[0][0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[0][1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
s[1][0] = LoadUnaligned16Msan(src1 + 0, overread_in_bytes + 0);
s[1][1] = LoadUnaligned16Msan(src1 + 8, overread_in_bytes + 16);
Square(s[0][0], sq_128[0]);
Square(s[1][0], sq_128[1]);
BoxFilterPreProcessLo(s, scales, sum3, sum5, square_sum3, square_sum5, sq_128,
ma3_128, b3_128, &ma5_0, b5_128);
sq[0][0] = SetrM128i(sq_128[0][2], sq_128[0][2]);
sq[0][1] = SetrM128i(sq_128[0][3], sq_128[0][3]);
sq[1][0] = SetrM128i(sq_128[1][2], sq_128[1][2]);
sq[1][1] = SetrM128i(sq_128[1][3], sq_128[1][3]);
ma3[0][0] = SetrM128i(ma3_128[0][0], ma3_128[0][0]);
ma3[1][0] = SetrM128i(ma3_128[1][0], ma3_128[1][0]);
ma5[0] = SetrM128i(ma5_0, ma5_0);
b3[0][0] = SetrM128i(b3_128[0][0], b3_128[0][0]);
b3[0][1] = SetrM128i(b3_128[0][1], b3_128[0][1]);
b3[1][0] = SetrM128i(b3_128[1][0], b3_128[1][0]);
b3[1][1] = SetrM128i(b3_128[1][1], b3_128[1][1]);
b5[0] = SetrM128i(b5_128[0], b5_128[0]);
b5[1] = SetrM128i(b5_128[1], b5_128[1]);
int x = 0;
do {
__m256i ma[3][4], mat[3][3], b[3][3][2], bt[3][3][2], p[2][2], ma3x[2][3],
ma5x[3];
BoxFilterPreProcess(
src0 + x + 8, src1 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), x + 8,
scales, sum3, sum5, square_sum3, square_sum5, sum_width, sq, ma3, b3,
ma5, b5);
Prepare3_8(ma3[0], ma3x[0]);
Prepare3_8(ma3[1], ma3x[1]);
Prepare3_8(ma5, ma5x);
Store343_444(ma3x[0], b3[0], x, &ma[1][2], &mat[1][2], &ma[2][1],
&mat[2][1], b[1][2], bt[1][2], b[2][1], bt[2][1], ma343[2],
ma444[1], b343[2], b444[1]);
Store343_444(ma3x[1], b3[1], x, &ma[2][2], &mat[2][2], b[2][2], bt[2][2],
ma343[3], ma444[2], b343[3], b444[2]);
ma[0][2] = Sum565Lo(ma5x);
ma[0][3] = Sum565Hi(ma5x);
ma[0][1] = _mm256_permute2x128_si256(ma[0][2], ma[0][3], 0x20);
ma[0][3] = _mm256_permute2x128_si256(ma[0][2], ma[0][3], 0x31);
StoreAligned32(ma565[1] + x + 0, ma[0][1]);
StoreAligned32(ma565[1] + x + 16, ma[0][3]);
Sum565(b5, b[0][1]);
StoreAligned64(b565[1] + x, b[0][1]);
const __m256i sr0_lo = LoadUnaligned32(src + x);
const __m256i sr1_lo = LoadUnaligned32(src + stride + x);
ma[0][0] = LoadAligned32(ma565[0] + x);
LoadAligned64(b565[0] + x, b[0][0]);
p[0][0] = CalculateFilteredOutputPass1(sr0_lo, ma[0], b[0]);
p[1][0] = CalculateFilteredOutput<4>(sr1_lo, ma[0][1], b[0][1]);
ma[1][0] = LoadAligned32(ma343[0] + x);
ma[1][1] = LoadAligned32(ma444[0] + x);
// Keeping the following 4 redundant lines is faster. The reason is that
// there are not enough registers available, and these values could be saved
// and loaded which is even slower.
ma[1][2] = LoadAligned32(ma343[2] + x); // Redundant line 1.
LoadAligned64(b343[0] + x, b[1][0]);
LoadAligned64(b444[0] + x, b[1][1]);
p[0][1] = CalculateFilteredOutputPass2(sr0_lo, ma[1], b[1]);
ma[2][0] = LoadAligned32(ma343[1] + x);
ma[2][1] = LoadAligned32(ma444[1] + x); // Redundant line 2.
LoadAligned64(b343[1] + x, b[2][0]);
p[1][1] = CalculateFilteredOutputPass2(sr1_lo, ma[2], b[2]);
const __m256i d00 = SelfGuidedDoubleMultiplier(sr0_lo, p[0], w0, w2);
ClipAndStore(dst + x, d00);
const __m256i d10x = SelfGuidedDoubleMultiplier(sr1_lo, p[1], w0, w2);
ClipAndStore(dst + stride + x, d10x);
Sum565(b5 + 3, bt[0][1]);
StoreAligned64(b565[1] + x + 16, bt[0][1]);
const __m256i sr0_hi = LoadUnaligned32(src + x + 16);
const __m256i sr1_hi = LoadUnaligned32(src + stride + x + 16);
ma[0][2] = LoadAligned32(ma565[0] + x + 16);
LoadAligned64(b565[0] + x + 16, bt[0][0]);
p[0][0] = CalculateFilteredOutputPass1(sr0_hi, ma[0] + 2, bt[0]);
p[1][0] = CalculateFilteredOutput<4>(sr1_hi, ma[0][3], bt[0][1]);
mat[1][0] = LoadAligned32(ma343[0] + x + 16);
mat[1][1] = LoadAligned32(ma444[0] + x + 16);
mat[1][2] = LoadAligned32(ma343[2] + x + 16); // Redundant line 3.
LoadAligned64(b343[0] + x + 16, bt[1][0]);
LoadAligned64(b444[0] + x + 16, bt[1][1]);
p[0][1] = CalculateFilteredOutputPass2(sr0_hi, mat[1], bt[1]);
mat[2][0] = LoadAligned32(ma343[1] + x + 16);
mat[2][1] = LoadAligned32(ma444[1] + x + 16); // Redundant line 4.
LoadAligned64(b343[1] + x + 16, bt[2][0]);
p[1][1] = CalculateFilteredOutputPass2(sr1_hi, mat[2], bt[2]);
const __m256i d01 = SelfGuidedDoubleMultiplier(sr0_hi, p[0], w0, w2);
ClipAndStore(dst + x + 16, d01);
const __m256i d11 = SelfGuidedDoubleMultiplier(sr1_hi, p[1], w0, w2);
ClipAndStore(dst + stride + x + 16, d11);
sq[0][0] = sq[0][6];
sq[0][1] = sq[0][7];
sq[1][0] = sq[1][6];
sq[1][1] = sq[1][7];
ma3[0][0] = ma3[0][2];
ma3[1][0] = ma3[1][2];
ma5[0] = ma5[2];
b3[0][0] = b3[0][5];
b3[0][1] = b3[0][6];
b3[1][0] = b3[1][5];
b3[1][1] = b3[1][6];
b5[0] = b5[5];
b5[1] = b5[6];
x += 32;
} while (x < width);
}
inline void BoxFilterLastRow(
const uint16_t* const src, const uint16_t* const src0, const int width,
const ptrdiff_t sum_width, const uint16_t scales[2], const int16_t w0,
const int16_t w2, uint16_t* const sum3[4], uint16_t* const sum5[5],
uint32_t* const square_sum3[4], uint32_t* const square_sum5[5],
uint16_t* const ma343, uint16_t* const ma444, uint16_t* const ma565,
uint32_t* const b343, uint32_t* const b444, uint32_t* const b565,
uint16_t* const dst) {
const ptrdiff_t overread_in_bytes =
kOverreadInBytesPass1_128 - sizeof(*src0) * width;
__m128i s[2], ma3_0, ma5_0, sq_128[4], b3_128[2], b5_128[2];
__m256i ma3[3], ma5[3], sq[8], b3[7], b5[7];
s[0] = LoadUnaligned16Msan(src0 + 0, overread_in_bytes + 0);
s[1] = LoadUnaligned16Msan(src0 + 8, overread_in_bytes + 16);
Square(s[0], sq_128);
BoxFilterPreProcessLastRowLo(s, scales, sum3, sum5, square_sum3, square_sum5,
sq_128, &ma3_0, &ma5_0, b3_128, b5_128);
sq[0] = SetrM128i(sq_128[2], sq_128[2]);
sq[1] = SetrM128i(sq_128[3], sq_128[3]);
ma3[0] = SetrM128i(ma3_0, ma3_0);
ma5[0] = SetrM128i(ma5_0, ma5_0);
b3[0] = SetrM128i(b3_128[0], b3_128[0]);
b3[1] = SetrM128i(b3_128[1], b3_128[1]);
b5[0] = SetrM128i(b5_128[0], b5_128[0]);
b5[1] = SetrM128i(b5_128[1], b5_128[1]);
int x = 0;
do {
__m256i ma[4], mat[4], b[3][2], bt[3][2], ma3x[3], ma5x[3], p[2];
BoxFilterPreProcessLastRow(
src0 + x + 8,
kOverreadInBytesPass1_256 + sizeof(*src0) * (x + 8 - width), sum_width,
x + 8, scales, sum3, sum5, square_sum3, square_sum5, sq, ma3, ma5, b3,
b5);
Prepare3_8(ma3, ma3x);
Prepare3_8(ma5, ma5x);
ma[2] = Sum565Lo(ma5x);
Sum565(b5, b[1]);
mat[1] = Sum565Hi(ma5x);
Sum565(b5 + 3, bt[1]);
ma[3] = Sum343Lo(ma3x);
Sum343(b3, b[2]);
mat[2] = Sum343Hi(ma3x);
Sum343(b3 + 3, bt[2]);
const __m256i sr_lo = LoadUnaligned32(src + x);
ma[0] = LoadAligned32(ma565 + x);
ma[1] = _mm256_permute2x128_si256(ma[2], mat[1], 0x20);
mat[1] = _mm256_permute2x128_si256(ma[2], mat[1], 0x31);
LoadAligned64(b565 + x, b[0]);
p[0] = CalculateFilteredOutputPass1(sr_lo, ma, b);
ma[0] = LoadAligned32(ma343 + x);
ma[1] = LoadAligned32(ma444 + x);
ma[2] = _mm256_permute2x128_si256(ma[3], mat[2], 0x20);
LoadAligned64(b343 + x, b[0]);
LoadAligned64(b444 + x, b[1]);
p[1] = CalculateFilteredOutputPass2(sr_lo, ma, b);
const __m256i d0 = SelfGuidedDoubleMultiplier(sr_lo, p, w0, w2);
const __m256i sr_hi = LoadUnaligned32(src + x + 16);
mat[0] = LoadAligned32(ma565 + x + 16);
LoadAligned64(b565 + x + 16, bt[0]);
p[0] = CalculateFilteredOutputPass1(sr_hi, mat, bt);
mat[0] = LoadAligned32(ma343 + x + 16);
mat[1] = LoadAligned32(ma444 + x + 16);
mat[2] = _mm256_permute2x128_si256(ma[3], mat[2], 0x31);
LoadAligned64(b343 + x + 16, bt[0]);
LoadAligned64(b444 + x + 16, bt[1]);
p[1] = CalculateFilteredOutputPass2(sr_hi, mat, bt);
const __m256i d1 = SelfGuidedDoubleMultiplier(sr_hi, p, w0, w2);
ClipAndStore(dst + x + 0, d0);
ClipAndStore(dst + x + 16, d1);
sq[0] = sq[6];
sq[1] = sq[7];
ma3[0] = ma3[2];
ma5[0] = ma5[2];
b3[0] = b3[5];
b3[1] = b3[6];
b5[0] = b5[5];
b5[1] = b5[6];
x += 32;
} while (x < width);
}
LIBGAV1_ALWAYS_INLINE void BoxFilterProcess(
const RestorationUnitInfo& restoration_info, const uint16_t* src,
const ptrdiff_t stride, const uint16_t* const top_border,
const ptrdiff_t top_border_stride, const uint16_t* bottom_border,
const ptrdiff_t bottom_border_stride, const int width, const int height,
SgrBuffer* const sgr_buffer, uint16_t* dst) {
const auto temp_stride = Align<ptrdiff_t>(width, 32);
const auto sum_width = temp_stride + 8;
const auto sum_stride = temp_stride + 32;
const int sgr_proj_index = restoration_info.sgr_proj_info.index;
const uint16_t* const scales = kSgrScaleParameter[sgr_proj_index]; // < 2^12.
const int16_t w0 = restoration_info.sgr_proj_info.multiplier[0];
const int16_t w1 = restoration_info.sgr_proj_info.multiplier[1];
const int16_t w2 = (1 << kSgrProjPrecisionBits) - w0 - w1;
uint16_t *sum3[4], *sum5[5], *ma343[4], *ma444[3], *ma565[2];
uint32_t *square_sum3[4], *square_sum5[5], *b343[4], *b444[3], *b565[2];
sum3[0] = sgr_buffer->sum3 + kSumOffset;
square_sum3[0] = sgr_buffer->square_sum3 + kSumOffset;
ma343[0] = sgr_buffer->ma343;
b343[0] = sgr_buffer->b343;
for (int i = 1; i <= 3; ++i) {
sum3[i] = sum3[i - 1] + sum_stride;
square_sum3[i] = square_sum3[i - 1] + sum_stride;
ma343[i] = ma343[i - 1] + temp_stride;
b343[i] = b343[i - 1] + temp_stride;
}
sum5[0] = sgr_buffer->sum5 + kSumOffset;
square_sum5[0] = sgr_buffer->square_sum5 + kSumOffset;
for (int i = 1; i <= 4; ++i) {
sum5[i] = sum5[i - 1] + sum_stride;
square_sum5[i] = square_sum5[i - 1] + sum_stride;
}
ma444[0] = sgr_buffer->ma444;
b444[0] = sgr_buffer->b444;
for (int i = 1; i <= 2; ++i) {
ma444[i] = ma444[i - 1] + temp_stride;
b444[i] = b444[i - 1] + temp_stride;
}
ma565[0] = sgr_buffer->ma565;
ma565[1] = ma565[0] + temp_stride;
b565[0] = sgr_buffer->b565;
b565[1] = b565[0] + temp_stride;
assert(scales[0] != 0);
assert(scales[1] != 0);
BoxSum(top_border, top_border_stride, width, sum_stride, temp_stride, sum3[0],
sum5[1], square_sum3[0], square_sum5[1]);
sum5[0] = sum5[1];
square_sum5[0] = square_sum5[1];
const uint16_t* const s = (height > 1) ? src + stride : bottom_border;
BoxSumFilterPreProcess(src, s, width, scales, sum3, sum5, square_sum3,
square_sum5, sum_width, ma343, ma444[0], ma565[0],
b343, b444[0], b565[0]);
sum5[0] = sgr_buffer->sum5 + kSumOffset;
square_sum5[0] = sgr_buffer->square_sum5 + kSumOffset;
for (int y = (height >> 1) - 1; y > 0; --y) {
Circulate4PointersBy2<uint16_t>(sum3);
Circulate4PointersBy2<uint32_t>(square_sum3);
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
BoxFilter(src + 3, src + 2 * stride, src + 3 * stride, stride, width,
scales, w0, w2, sum3, sum5, square_sum3, square_sum5, sum_width,
ma343, ma444, ma565, b343, b444, b565, dst);
src += 2 * stride;
dst += 2 * stride;
Circulate4PointersBy2<uint16_t>(ma343);
Circulate4PointersBy2<uint32_t>(b343);
std::swap(ma444[0], ma444[2]);
std::swap(b444[0], b444[2]);
std::swap(ma565[0], ma565[1]);
std::swap(b565[0], b565[1]);
}
Circulate4PointersBy2<uint16_t>(sum3);
Circulate4PointersBy2<uint32_t>(square_sum3);
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
if ((height & 1) == 0 || height > 1) {
const uint16_t* sr[2];
if ((height & 1) == 0) {
sr[0] = bottom_border;
sr[1] = bottom_border + bottom_border_stride;
} else {
sr[0] = src + 2 * stride;
sr[1] = bottom_border;
}
BoxFilter(src + 3, sr[0], sr[1], stride, width, scales, w0, w2, sum3, sum5,
square_sum3, square_sum5, sum_width, ma343, ma444, ma565, b343,
b444, b565, dst);
}
if ((height & 1) != 0) {
if (height > 1) {
src += 2 * stride;
dst += 2 * stride;
Circulate4PointersBy2<uint16_t>(sum3);
Circulate4PointersBy2<uint32_t>(square_sum3);
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
Circulate4PointersBy2<uint16_t>(ma343);
Circulate4PointersBy2<uint32_t>(b343);
std::swap(ma444[0], ma444[2]);
std::swap(b444[0], b444[2]);
std::swap(ma565[0], ma565[1]);
std::swap(b565[0], b565[1]);
}
BoxFilterLastRow(src + 3, bottom_border + bottom_border_stride, width,
sum_width, scales, w0, w2, sum3, sum5, square_sum3,
square_sum5, ma343[0], ma444[0], ma565[0], b343[0],
b444[0], b565[0], dst);
}
}
inline void BoxFilterProcessPass1(const RestorationUnitInfo& restoration_info,
const uint16_t* src, const ptrdiff_t stride,
const uint16_t* const top_border,
const ptrdiff_t top_border_stride,
const uint16_t* bottom_border,
const ptrdiff_t bottom_border_stride,
const int width, const int height,
SgrBuffer* const sgr_buffer, uint16_t* dst) {
const auto temp_stride = Align<ptrdiff_t>(width, 32);
const auto sum_width = temp_stride + 8;
const auto sum_stride = temp_stride + 32;
const int sgr_proj_index = restoration_info.sgr_proj_info.index;
const uint32_t scale = kSgrScaleParameter[sgr_proj_index][0]; // < 2^12.
const int16_t w0 = restoration_info.sgr_proj_info.multiplier[0];
uint16_t *sum5[5], *ma565[2];
uint32_t *square_sum5[5], *b565[2];
sum5[0] = sgr_buffer->sum5 + kSumOffset;
square_sum5[0] = sgr_buffer->square_sum5 + kSumOffset;
for (int i = 1; i <= 4; ++i) {
sum5[i] = sum5[i - 1] + sum_stride;
square_sum5[i] = square_sum5[i - 1] + sum_stride;
}
ma565[0] = sgr_buffer->ma565;
ma565[1] = ma565[0] + temp_stride;
b565[0] = sgr_buffer->b565;
b565[1] = b565[0] + temp_stride;
assert(scale != 0);
BoxSum<5>(top_border, top_border_stride, width, sum_stride, temp_stride,
sum5[1], square_sum5[1]);
sum5[0] = sum5[1];
square_sum5[0] = square_sum5[1];
const uint16_t* const s = (height > 1) ? src + stride : bottom_border;
BoxSumFilterPreProcess5(src, s, width, scale, sum5, square_sum5, sum_width,
ma565[0], b565[0]);
sum5[0] = sgr_buffer->sum5 + kSumOffset;
square_sum5[0] = sgr_buffer->square_sum5 + kSumOffset;
for (int y = (height >> 1) - 1; y > 0; --y) {
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
BoxFilterPass1(src + 3, src + 2 * stride, src + 3 * stride, stride, sum5,
square_sum5, width, sum_width, scale, w0, ma565, b565, dst);
src += 2 * stride;
dst += 2 * stride;
std::swap(ma565[0], ma565[1]);
std::swap(b565[0], b565[1]);
}
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
if ((height & 1) == 0 || height > 1) {
const uint16_t* sr[2];
if ((height & 1) == 0) {
sr[0] = bottom_border;
sr[1] = bottom_border + bottom_border_stride;
} else {
sr[0] = src + 2 * stride;
sr[1] = bottom_border;
}
BoxFilterPass1(src + 3, sr[0], sr[1], stride, sum5, square_sum5, width,
sum_width, scale, w0, ma565, b565, dst);
}
if ((height & 1) != 0) {
src += 3;
if (height > 1) {
src += 2 * stride;
dst += 2 * stride;
std::swap(ma565[0], ma565[1]);
std::swap(b565[0], b565[1]);
Circulate5PointersBy2<uint16_t>(sum5);
Circulate5PointersBy2<uint32_t>(square_sum5);
}
BoxFilterPass1LastRow(src, bottom_border + bottom_border_stride, width,
sum_width, scale, w0, sum5, square_sum5, ma565[0],
b565[0], dst);
}
}
inline void BoxFilterProcessPass2(const RestorationUnitInfo& restoration_info,
const uint16_t* src, const ptrdiff_t stride,
const uint16_t* const top_border,
const ptrdiff_t top_border_stride,
const uint16_t* bottom_border,
const ptrdiff_t bottom_border_stride,
const int width, const int height,
SgrBuffer* const sgr_buffer, uint16_t* dst) {
assert(restoration_info.sgr_proj_info.multiplier[0] == 0);
const auto temp_stride = Align<ptrdiff_t>(width, 32);
const auto sum_width = temp_stride + 8;
const auto sum_stride = temp_stride + 32;
const int16_t w1 = restoration_info.sgr_proj_info.multiplier[1];
const int16_t w0 = (1 << kSgrProjPrecisionBits) - w1;
const int sgr_proj_index = restoration_info.sgr_proj_info.index;
const uint32_t scale = kSgrScaleParameter[sgr_proj_index][1]; // < 2^12.
uint16_t *sum3[3], *ma343[3], *ma444[2];
uint32_t *square_sum3[3], *b343[3], *b444[2];
sum3[0] = sgr_buffer->sum3 + kSumOffset;
square_sum3[0] = sgr_buffer->square_sum3 + kSumOffset;
ma343[0] = sgr_buffer->ma343;
b343[0] = sgr_buffer->b343;
for (int i = 1; i <= 2; ++i) {
sum3[i] = sum3[i - 1] + sum_stride;
square_sum3[i] = square_sum3[i - 1] + sum_stride;
ma343[i] = ma343[i - 1] + temp_stride;
b343[i] = b343[i - 1] + temp_stride;
}
ma444[0] = sgr_buffer->ma444;
ma444[1] = ma444[0] + temp_stride;
b444[0] = sgr_buffer->b444;
b444[1] = b444[0] + temp_stride;
assert(scale != 0);
BoxSum<3>(top_border, top_border_stride, width, sum_stride, temp_stride,
sum3[0], square_sum3[0]);
BoxSumFilterPreProcess3<false>(src, width, scale, sum3, square_sum3,
sum_width, ma343[0], nullptr, b343[0],
nullptr);
Circulate3PointersBy1<uint16_t>(sum3);
Circulate3PointersBy1<uint32_t>(square_sum3);
const uint16_t* s;
if (height > 1) {
s = src + stride;
} else {
s = bottom_border;
bottom_border += bottom_border_stride;
}
BoxSumFilterPreProcess3<true>(s, width, scale, sum3, square_sum3, sum_width,
ma343[1], ma444[0], b343[1], b444[0]);
for (int y = height - 2; y > 0; --y) {
Circulate3PointersBy1<uint16_t>(sum3);
Circulate3PointersBy1<uint32_t>(square_sum3);
BoxFilterPass2(src + 2, src + 2 * stride, width, sum_width, scale, w0, sum3,
square_sum3, ma343, ma444, b343, b444, dst);
src += stride;
dst += stride;
Circulate3PointersBy1<uint16_t>(ma343);
Circulate3PointersBy1<uint32_t>(b343);
std::swap(ma444[0], ma444[1]);
std::swap(b444[0], b444[1]);
}
int y = std::min(height, 2);
src += 2;
do {
Circulate3PointersBy1<uint16_t>(sum3);
Circulate3PointersBy1<uint32_t>(square_sum3);
BoxFilterPass2(src, bottom_border, width, sum_width, scale, w0, sum3,
square_sum3, ma343, ma444, b343, b444, dst);
src += stride;
dst += stride;
bottom_border += bottom_border_stride;
Circulate3PointersBy1<uint16_t>(ma343);
Circulate3PointersBy1<uint32_t>(b343);
std::swap(ma444[0], ma444[1]);
std::swap(b444[0], b444[1]);
} while (--y != 0);
}
// If |width| is non-multiple of 32, up to 31 more pixels are written to |dest|
// in the end of each row. It is safe to overwrite the output as it will not be
// part of the visible frame.
void SelfGuidedFilter_AVX2(
const RestorationUnitInfo& restoration_info, const void* const source,
const ptrdiff_t stride, const void* const top_border,
const ptrdiff_t top_border_stride, const void* const bottom_border,
const ptrdiff_t bottom_border_stride, const int width, const int height,
RestorationBuffer* const restoration_buffer, void* const dest) {
const int index = restoration_info.sgr_proj_info.index;
const int radius_pass_0 = kSgrProjParams[index][0]; // 2 or 0
const int radius_pass_1 = kSgrProjParams[index][2]; // 1 or 0
const auto* const src = static_cast<const uint16_t*>(source);
const auto* const top = static_cast<const uint16_t*>(top_border);
const auto* const bottom = static_cast<const uint16_t*>(bottom_border);
auto* const dst = static_cast<uint16_t*>(dest);
SgrBuffer* const sgr_buffer = &restoration_buffer->sgr_buffer;
if (radius_pass_1 == 0) {
// |radius_pass_0| and |radius_pass_1| cannot both be 0, so we have the
// following assertion.
assert(radius_pass_0 != 0);
BoxFilterProcessPass1(restoration_info, src - 3, stride, top - 3,
top_border_stride, bottom - 3, bottom_border_stride,
width, height, sgr_buffer, dst);
} else if (radius_pass_0 == 0) {
BoxFilterProcessPass2(restoration_info, src - 2, stride, top - 2,
top_border_stride, bottom - 2, bottom_border_stride,
width, height, sgr_buffer, dst);
} else {
BoxFilterProcess(restoration_info, src - 3, stride, top - 3,
top_border_stride, bottom - 3, bottom_border_stride, width,
height, sgr_buffer, dst);
}
}
void Init10bpp() {
Dsp* const dsp = dsp_internal::GetWritableDspTable(kBitdepth10);
assert(dsp != nullptr);
#if DSP_ENABLED_10BPP_AVX2(WienerFilter)
dsp->loop_restorations[0] = WienerFilter_AVX2;
#endif
#if DSP_ENABLED_10BPP_AVX2(SelfGuidedFilter)
dsp->loop_restorations[1] = SelfGuidedFilter_AVX2;
#endif
}
} // namespace
void LoopRestorationInit10bpp_AVX2() { Init10bpp(); }
} // namespace dsp
} // namespace libgav1
#else // !(LIBGAV1_TARGETING_AVX2 && LIBGAV1_MAX_BITDEPTH >= 10)
namespace libgav1 {
namespace dsp {
void LoopRestorationInit10bpp_AVX2() {}
} // namespace dsp
} // namespace libgav1
#endif // LIBGAV1_TARGETING_AVX2 && LIBGAV1_MAX_BITDEPTH >= 10
| 42.025332 | 80 | 0.632335 | P-404 |
b390094a098032f0a8cc5c56a09b2fa52d2d436b | 3,729 | hpp | C++ | Include/Httplib/Auth/Authentication.hpp | Andres6936/Http.Lib | 37aaa0555ff8481e26c3855376d1fa2dc087bdfd | [
"MIT"
] | 1 | 2021-06-20T08:38:16.000Z | 2021-06-20T08:38:16.000Z | Include/Httplib/Auth/Authentication.hpp | Andres6936/Http.Lib | 37aaa0555ff8481e26c3855376d1fa2dc087bdfd | [
"MIT"
] | null | null | null | Include/Httplib/Auth/Authentication.hpp | Andres6936/Http.Lib | 37aaa0555ff8481e26c3855376d1fa2dc087bdfd | [
"MIT"
] | null | null | null | // Joan Andrés (@Andres6936) Github.
#ifndef HTTPLIB_AUTHENTICATION_HPP
#define HTTPLIB_AUTHENTICATION_HPP
#include <string>
#include <utility>
#include <Httplib/ZLib/Base64.hpp>
namespace httplib {
inline std::pair<std::string, std::string>
make_basic_authentication_header(const std::string &username,
const std::string &password,
bool is_proxy = false) {
auto field = "Basic " + detail::base64_encode(username + ":" + password);
auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
return std::make_pair(key, std::move(field));
}
inline std::pair<std::string, std::string>
make_bearer_token_authentication_header(const std::string &token,
bool is_proxy = false) {
auto field = "Bearer " + token;
auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
return std::make_pair(key, std::move(field));
}
inline bool parse_www_authenticate(const Response &res,
std::map<std::string, std::string> &auth,
bool is_proxy) {
auto auth_key = is_proxy ? "Proxy-Authenticate" : "WWW-Authenticate";
if (res.has_header(auth_key)) {
static auto re = std::regex(R"~((?:(?:,\s*)?(.+?)=(?:"(.*?)"|([^,]*))))~");
auto s = res.get_header_value(auth_key);
auto pos = s.find(' ');
if (pos != std::string::npos) {
auto type = s.substr(0, pos);
if (type == "Basic") {
return false;
} else if (type == "Digest") {
s = s.substr(pos + 1);
auto beg = std::sregex_iterator(s.begin(), s.end(), re);
for (auto i = beg; i != std::sregex_iterator(); ++i) {
auto m = *i;
auto key = s.substr(static_cast<size_t>(m.position(1)),
static_cast<size_t>(m.length(1)));
auto val = m.length(2) > 0
? s.substr(static_cast<size_t>(m.position(2)),
static_cast<size_t>(m.length(2)))
: s.substr(static_cast<size_t>(m.position(3)),
static_cast<size_t>(m.length(3)));
auth[key] = val;
}
return true;
}
}
}
return false;
}
#ifdef CPPHTTPLIB_OPENSSL_SUPPORT
inline std::pair<std::string, std::string> make_digest_authentication_header(
const Request &req, const std::map<std::string, std::string> &auth,
size_t cnonce_count, const std::string &cnonce, const std::string &username,
const std::string &password, bool is_proxy = false) {
using namespace std;
string nc;
{
stringstream ss;
ss << setfill('0') << setw(8) << hex << cnonce_count;
nc = ss.str();
}
auto qop = auth.at("qop");
if (qop.find("auth-int") != std::string::npos) {
qop = "auth-int";
} else {
qop = "auth";
}
std::string algo = "MD5";
if (auth.find("algorithm") != auth.end()) { algo = auth.at("algorithm"); }
string response;
{
auto H = algo == "SHA-256"
? detail::SHA_256
: algo == "SHA-512" ? detail::SHA_512 : detail::MD5;
auto A1 = username + ":" + auth.at("realm") + ":" + password;
auto A2 = req.method + ":" + req.path;
if (qop == "auth-int") { A2 += ":" + H(req.body); }
response = H(H(A1) + ":" + auth.at("nonce") + ":" + nc + ":" + cnonce +
":" + qop + ":" + H(A2));
}
auto field = "Digest username=\"" + username + "\", realm=\"" +
auth.at("realm") + "\", nonce=\"" + auth.at("nonce") +
"\", uri=\"" + req.path + "\", algorithm=" + algo +
", qop=" + qop + ", nc=\"" + nc + "\", cnonce=\"" + cnonce +
"\", response=\"" + response + "\"";
auto key = is_proxy ? "Proxy-Authorization" : "Authorization";
return std::make_pair(key, field);
}
#endif
} // namespace httplib
#endif // HTTPLIB_AUTHENTICATION_HPP
| 31.871795 | 80 | 0.568249 | Andres6936 |
b3926e8af1b60352a2d14c322e39055de5434023 | 4,900 | hh | C++ | analysis/machine_learning/ml_data.hh | ssrg-vt/aira | 96a830480d1ed8317e0175a10d950d7991fb2bb7 | [
"Unlicense"
] | 3 | 2018-12-17T08:20:40.000Z | 2020-02-24T02:08:23.000Z | analysis/machine_learning/ml_data.hh | ssrg-vt/aira | 96a830480d1ed8317e0175a10d950d7991fb2bb7 | [
"Unlicense"
] | null | null | null | analysis/machine_learning/ml_data.hh | ssrg-vt/aira | 96a830480d1ed8317e0175a10d950d7991fb2bb7 | [
"Unlicense"
] | null | null | null | #ifndef _ML_DATA_HH
#define _ML_DATA_HH
#include <iostream>
#include <opencv/cv.h>
#include <opencv/ml.h>
using namespace cv;
class Transform {
public:
const int input_dimension;
const int output_dimension;
private:
const Mat _include; // Vector of booleans, include this feature or not
const Mat _mean_adjust; // Value to substract to get zero-mean
const Mat _range_scale; // Value to divide by to get constant range
const Mat _projection; // rows: output-dimension, cols: input-dimension
public:
Transform(int i, int o, const Mat &inc, const Mat &m, const Mat &r,
const Mat &p) : input_dimension(i), output_dimension(o),
_include(inc), _mean_adjust(m), _range_scale(r),
_projection(p)
{
assert(inc.type() == CV_8U);
assert(inc.rows == 1);
assert(inc.cols == i);
assert(m.type() == CV_64F);
assert(m.rows == 1);
assert(r.type() == CV_64F);
assert(r.rows == 1);
assert(p.type() == CV_64F);
assert(p.cols == m.cols); // We have a mean-adjust for all input-features.
assert(p.cols == r.cols); // We have a range-scale for all input-features.
assert(p.rows == o);
}
~Transform() {}
// Save to an XML file.
void save(const char *fname) const;
// Don't use the "return Mat" structure used everywhere in this code as this
// function must be extremely fast. So use a reference.
void project(const Mat &in, Mat &out) const;
const Mat& include() const { return _include; }
bool include(int i) const { return _include.at<unsigned char>(i) == 1; }
const Mat& mean_adjust() const { return _mean_adjust; }
double mean_adjust(int i) const { return _mean_adjust.at<double>(i); }
const Mat& range_scale() const { return _range_scale; }
double range_scale(int i) const { return _range_scale.at<double>(i); }
const Mat& projection() const { return _projection; }
double projection(int i) const { return _projection.at<double>(i); }
const Transform switch_include(const Mat &i) const
{
assert(i.cols <= output_dimension);
return Transform(input_dimension, i.cols, i, _mean_adjust,
_range_scale, _projection);
}
const Transform switch_mean(const Mat &m) const
{
return Transform(input_dimension, output_dimension, _include, m,
_range_scale, _projection);
}
const Transform switch_range(const Mat &r) const
{
return Transform(input_dimension, output_dimension, _include, _mean_adjust,
r, _projection);
}
const Transform switch_projection(const Mat &p) const
{
assert(p.rows <= output_dimension);
return Transform(input_dimension, p.rows, _include, _mean_adjust,
_range_scale, p);
}
};
class Data {
public:
const Mat features;
const Mat labels;
const Transform transform;
Data(const Mat &f, const Mat &l, const Transform &t)
: features(f), labels(l), transform(t)
{
assert(f.type() == CV_64F);
assert(l.type() == CV_64F);
assert(f.rows == l.rows); // All features have labels.
assert(f.cols == t.output_dimension); // Project to correct dimensionality.
}
~Data() {}
const Mat feature(int i) const { return features.col(i); }
double point(int i, int j) const { return features.at<double>(i, j); }
double label_point(int i, int j) const { return labels.at<double>(i, j); }
const Mat feature_data(int i) const { return features.row(i); }
const Mat label_data(int i) const { return labels.row(i); }
int num_features() const { return features.cols; }
int num_labels() const { return labels.cols; }
int num_data() const { return features.rows; }
void describe(std::ostream &s, const std::string &msg) const;
void describe_features(std::ostream &s) const;
// Note: These two functions only transforms labels, so does not need to be
// recorded in 'transform' as this does not affect the test set (except for
// evaluating effectiveness).
Data speedup_labels() const;
Data probabilistic_labels() const;
Data append(const Data &other) const;
Data cut_label(int label) const;
Data cut_feature(int feature) const;
Data cut_bad_features() const;
Data cut_profile_features() const;
Data cut_empty_features() const;
Data adjust_means() const;
Data scale_ranges(bool use_stddev) const;
Data apply_pca(double variance) const;
Data apply_pca(int target_features) const;
private:
Data pca_helper(PCA &pca) const;
const Mat calculate_means(const Mat &features) const;
const Mat calculate_ranges(const Mat &features) const;
};
const Data transform_labels(const Data &data, int knn_k, bool cut_x86,
bool cut_tilera, bool cut_gpu, bool speedup,
bool prob);
const Transform build_identity_transform(int dimensions);
const Transform load_transform(const char *fname);
#endif // _ML_DATA_HH
| 35.251799 | 79 | 0.677959 | ssrg-vt |
b393c0652240bdc03fc3ce5f55bbfff84e879e37 | 3,679 | hpp | C++ | Include/xsim/xsim.hpp | raving-bots/expansim-sdk | 22f5c794523abbe9c27688963b607b13671ff118 | [
"BSL-1.0"
] | 1 | 2020-01-17T14:10:22.000Z | 2020-01-17T14:10:22.000Z | Include/xsim/xsim.hpp | raving-bots/expansim-sdk | 22f5c794523abbe9c27688963b607b13671ff118 | [
"BSL-1.0"
] | null | null | null | Include/xsim/xsim.hpp | raving-bots/expansim-sdk | 22f5c794523abbe9c27688963b607b13671ff118 | [
"BSL-1.0"
] | null | null | null | // Copyright Raving Bots 2018-2020
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file SDK-LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
#pragma once
#include <string>
#include <unordered_map>
#include <tuple>
#include <functional>
#include <yymp/typelist_fwd.hpp>
#include <yymp/for_each.hpp>
#include <xsim/utils.hpp>
#include <xsim/types.hpp>
#include <xsim/logs.hpp>
#if defined(XSIM_PLUGINS_TEST) && __has_include(<xsim/generated/test/abi.hpp>)
# include <xsim/generated/test/abi.hpp>
#else
# include <xsim/generated/abi.hpp>
#endif
namespace xsim
{
template <typename... Interfaces>
struct PluginV1 : Interfaces...
{
using Implements = yymp::typelist<Interfaces...>;
};
struct IPluginWrapper
{
virtual ~IPluginWrapper() = default;
virtual int32_t QueryInterface(const wchar_t* name, void** output, uint64_t* checksum) noexcept = 0;
};
namespace detail
{
template <typename Plugin>
struct PluginWrapper final : IPluginV1, IPluginWrapper
{
explicit PluginWrapper()
{
RegisterWrapper<IPluginV1>();
yymp::for_each(typename Plugin::Implements{}, [&](auto item)
{
(void)item; // only need the type
using Interface = typename decltype(item)::type;
RegisterPlugin<Interface>();
});
}
virtual ~PluginWrapper() = default;
void OnLoad() noexcept override
{
xsim::Protect([&]
{
m_Plugin = std::make_unique<Plugin>();
});
}
void OnUnload() noexcept override
{
xsim::Protect([&]
{
m_Plugin.reset();
});
}
int32_t QueryInterface(const wchar_t* name, void** output, uint64_t* checksum) noexcept override
{
if (auto it = m_Interfaces.find(name); it != m_Interfaces.end())
{
*checksum = it->second.m_Checksum;
*output = it->second.m_GetPointer(m_Plugin.get());
return 1;
}
return 0;
}
private:
struct ImplementedInterface
{
uint64_t m_Checksum{};
std::function<void*(Plugin*)> m_GetPointer{};
ImplementedInterface(uint64_t checksum, std::function<void*(Plugin*)> getPointer)
: m_Checksum(checksum)
, m_GetPointer(std::move(getPointer))
{
}
};
template <typename Interface>
void RegisterPlugin()
{
Register<Interface>([](Plugin* plugin) -> void*
{
return static_cast<Interface*>(plugin);
});
}
template <typename Interface>
void RegisterWrapper()
{
Register<Interface>([=](Plugin*)-> void*
{
return this;
});
}
template <typename Interface>
void Register(std::function<void*(Plugin*)> getPointer)
{
using Traits = InterfaceTraits<Interface>;
auto name = Traits::Name;
auto checksum = Traits::Checksum;
m_Interfaces.emplace(name, ImplementedInterface(checksum, std::move(getPointer)));
}
std::unique_ptr<Plugin> m_Plugin{};
std::unordered_map<std::wstring, ImplementedInterface> m_Interfaces{};
};
XSIM_EXPORT int32_t QueryInterface(const wchar_t* name, void** output, uint64_t* checksum) noexcept;
}
template <typename Plugin>
std::unique_ptr<IPluginWrapper> MakePlugin()
{
static_assert(
std::is_default_constructible<Plugin>::value, "The plugin type must be default-constructible"
);
static_assert(
sizeof(typename Plugin::Implements) != 0, "The plugin type must derive from PluginV1 for the SDK framework to work"
);
return std::unique_ptr<IPluginWrapper>(new detail::PluginWrapper<Plugin>());
}
std::unique_ptr<IPluginWrapper> GetPlugin();
}
| 24.045752 | 119 | 0.650177 | raving-bots |
b394ee2f0b9391496d730fb7c4ab16cd46bb1723 | 4,447 | cpp | C++ | com/win32comext/axcontrol/src/PyIViewObject2.cpp | huanyin88/Mod-Pywin32-For-Python3.x-DDE | 992931aa534357d54aaac34077f0128d3a740e5e | [
"Apache-2.0"
] | 3 | 2020-06-18T16:57:44.000Z | 2020-07-21T17:52:06.000Z | com/win32comext/axcontrol/src/PyIViewObject2.cpp | huanyin88/Mod-Pywin32-For-Python3.x-DDE | 992931aa534357d54aaac34077f0128d3a740e5e | [
"Apache-2.0"
] | null | null | null | com/win32comext/axcontrol/src/PyIViewObject2.cpp | huanyin88/Mod-Pywin32-For-Python3.x-DDE | 992931aa534357d54aaac34077f0128d3a740e5e | [
"Apache-2.0"
] | null | null | null | // This file implements the IViewObject2 Interface and Gateway for Python.
// Generated by makegw.py
#include "axcontrol_pch.h"
#include "PyIViewObject.h"
#include "PyIViewObject2.h"
// @doc - This file contains autoduck documentation
// ---------------------------------------------------
//
// Interface Implementation
PyIViewObject2::PyIViewObject2(IUnknown *pdisp) : PyIViewObject(pdisp) { ob_type = &type; }
PyIViewObject2::~PyIViewObject2() {}
/* static */ IViewObject2 *PyIViewObject2::GetI(PyObject *self) { return (IViewObject2 *)PyIViewObject::GetI(self); }
// @pymethod |PyIViewObject2|GetExtent|Description of GetExtent.
PyObject *PyIViewObject2::GetExtent(PyObject *self, PyObject *args)
{
IViewObject2 *pIVO2 = GetI(self);
if (pIVO2 == NULL)
return NULL;
// @pyparm int|dwDrawAspect||Description for dwDrawAspect
// @pyparm int|lindex||Description for lindex
// @pyparm <o PyDVTARGETDEVICE>|targetDevice||Description for lindex
DVTARGETDEVICE *ptd;
PyObject *obptd;
DWORD dwDrawAspect;
LONG lindex;
if (!PyArg_ParseTuple(args, "iiO:GetExtent", &dwDrawAspect, &lindex, &obptd))
return NULL;
BOOL bPythonIsHappy = TRUE;
if (bPythonIsHappy && !PyObject_AsDVTARGETDEVICE(obptd, &ptd))
bPythonIsHappy = FALSE;
if (!bPythonIsHappy)
return NULL;
SIZE sizel;
HRESULT hr;
PY_INTERFACE_PRECALL;
hr = pIVO2->GetExtent(dwDrawAspect, lindex, ptd, &sizel);
PY_INTERFACE_POSTCALL;
if (FAILED(hr))
return OleSetOleError(hr);
return Py_BuildValue("ll", sizel.cx, sizel.cy);
}
// @object PyIViewObject2|Description of the interface
static struct PyMethodDef PyIViewObject2_methods[] = {
{"GetExtent", PyIViewObject2::GetExtent, 1}, // @pymeth GetExtent|Description of GetExtent
{NULL}};
PyComTypeObject PyIViewObject2::type("PyIViewObject2", &PyIViewObject::type, sizeof(PyIViewObject2),
PyIViewObject2_methods, GET_PYCOM_CTOR(PyIViewObject2));
// ---------------------------------------------------
//
// Gateway Implementation
STDMETHODIMP PyGViewObject2::Draw(DWORD dwDrawAspect, LONG lindex, void __RPC_FAR *pvAspect,
DVTARGETDEVICE __RPC_FAR *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds,
LPCRECTL lprcWBounds, BOOL(STDMETHODCALLTYPE __RPC_FAR *pfnContinue)(ULONG_PTR),
ULONG_PTR dwContinue)
{
return PyGViewObject::Draw(dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds,
pfnContinue, dwContinue);
}
STDMETHODIMP PyGViewObject2::GetColorSet(DWORD dwDrawAspect, LONG lindex, void __RPC_FAR *pvAspect,
DVTARGETDEVICE __RPC_FAR *ptd, HDC hicTargetDev,
LOGPALETTE __RPC_FAR *__RPC_FAR *ppColorSet)
{
return PyGViewObject::GetColorSet(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet);
}
STDMETHODIMP PyGViewObject2::Freeze(DWORD dwDrawAspect, LONG lindex, void __RPC_FAR *pvAspect,
DWORD __RPC_FAR *pdwFreeze)
{
return PyGViewObject::Freeze(dwDrawAspect, lindex, pvAspect, pdwFreeze);
}
STDMETHODIMP PyGViewObject2::Unfreeze(DWORD dwFreeze) { return PyGViewObject::Unfreeze(dwFreeze); }
STDMETHODIMP PyGViewObject2::SetAdvise(DWORD aspects, DWORD advf, IAdviseSink __RPC_FAR *pAdvSink)
{
return PyGViewObject::SetAdvise(aspects, advf, pAdvSink);
}
STDMETHODIMP PyGViewObject2::GetAdvise(DWORD __RPC_FAR *pAspects, DWORD __RPC_FAR *pAdvf,
IAdviseSink __RPC_FAR *__RPC_FAR *ppAdvSink)
{
return PyGViewObject::GetAdvise(pAspects, pAdvf, ppAdvSink);
}
STDMETHODIMP PyGViewObject2::GetExtent(
/* [in] */ DWORD dwDrawAspect,
/* [in] */ LONG lindex,
/* [unique][in] */ DVTARGETDEVICE __RPC_FAR *ptd,
/* [out] */ LPSIZEL lpsizel)
{
PY_GATEWAY_METHOD;
PyObject *obptd = PyObject_FromDVTARGETDEVICE(ptd);
if (obptd == NULL)
return PyCom_HandlePythonFailureToCOM();
PyObject *result;
HRESULT hr = InvokeViaPolicy("GetExtent", &result, "iiO", dwDrawAspect, lindex, obptd);
Py_DECREF(obptd);
if (FAILED(hr))
return hr;
if (!PyArg_ParseTuple(result, "ll", &lpsizel->cx, &lpsizel->cx))
hr = PyCom_HandlePythonFailureToCOM();
return hr;
}
| 38.336207 | 117 | 0.666067 | huanyin88 |
b394f91427c5e81209e4319d9cd100da0bcf9e78 | 3,053 | hpp | C++ | experimental/vector_implementation/vector.hpp | jamesjallorina/Data_Structures_And_Algorithm_Analysis_in_CPP | 1162eae63ef894419d5e806541129adf73817130 | [
"MIT"
] | 3 | 2019-07-07T17:24:46.000Z | 2020-03-15T23:21:39.000Z | experimental/vector_implementation/vector.hpp | jamesjallorina/Data_Structures_And_Algorithm_Analysis_in_CPP | 1162eae63ef894419d5e806541129adf73817130 | [
"MIT"
] | null | null | null | experimental/vector_implementation/vector.hpp | jamesjallorina/Data_Structures_And_Algorithm_Analysis_in_CPP | 1162eae63ef894419d5e806541129adf73817130 | [
"MIT"
] | null | null | null | #ifndef EXPERIMENTAL_VECTOR_IMPLEMENTATION_VECTOR_HPP
#define EXPERIMENTAL_VECTOR_IMPLEMENTATION_VECTOR_HPP
#include <algorithm>
namespace experimental {
namespace vector_implementation
{
template <typename Object>
class vector
{
public:
explicit vector ( int initSize = 0 ) : theSize{ initSize },
theCapacity{ initSize + SPARE_CAPACITY }
{ objects = new Object[ theCapacity ]; }
vector( const vector & rhs ) : theSize{ rhs.theSize },
theCapacity{ rhs.theCapacity }, objects{ nullptr }
{
objects = new Object[ theCapacity ];
for( int k = 0; k < theSize; ++k )
objects[ k ] = rhs.objects[ k ];
}
vector & operator= ( const vector & rhs )
{
vector copy = rhs;
std::swap( *this, copy );
return *this;
}
~vector() { delete [] objects; }
vector( vector && rhs ) noexcept : theSize{ rhs.theSize },
theCapacity{ rhs.theCapacity }, objects{ rhs.objects }
{
rhs.objects = nullptr;
rhs.theSize = 0;
rhs.theCapacity = 0;
}
vector &operator= ( vector && rhs ) noexcept
{
std::swap( theSize, rhs.theSize );
std::swap( theCapacity, rhs.theCapacity);
std::swap( objects, rhs.objects );
return *this;
}
void resize( int newSize )
{
if( newSize > theCapacity )
reserve( newSize * 2 );
theSize = newSize;
}
void reserve( int newCapacity )
{
if( newCapacity < theSize )
return;
Object *newArray = new Object[ newCapacity ];
for(int k = 0; k < theSize; ++k)
newArray[ k ] = std::move( objects[ k ] );
theCapacity = newCapacity;
std::swap( objects, newArray );
delete [] newArray;
}
Object &operator[] ( int index )
{ return objects[ index ]; }
const Object & operator[] ( int index ) const
{ return objects[ index ]; }
bool empty( ) const
{ return size() == 0; }
int size( ) const
{ return theSize; }
int capacity( ) const
{ return theCapacity; }
void push_back( const Object & x )
{
if( theSize == theCapacity )
reserve( 2 * theCapacity + 1 );
objects[ theSize++ ] = x;
}
void push_back( Object && x )
{
if( theSize == theCapacity )
reserve( 2 * theCapacity + 1);
objects[ theSize++ ] = std::move( x );
}
void pop_back( )
{
--theSize;
}
const Object & back ( ) const
{
return objects[ theSize - 1 ];
}
using iterator = Object *;
using const_iterator = const Object *;
iterator begin( )
{ return &objects[ 0 ]; }
const_iterator begin( ) const
{ return &objects[ 0 ]; }
iterator end( )
{ return &objects[ size() ]; }
const_iterator end( ) const
{ return &objects[ size() ]; }
static constexpr short SPARE_CAPACITY = 16;
private:
int theSize;
int theCapacity;
Object * objects;
};
} // namespace vector_implementation
} // namespace experimental
#endif //EXPERIMENTAL_VECTOR_IMPLEMENTATION_VECTOR_HPP
| 22.123188 | 64 | 0.585981 | jamesjallorina |
b395fbb7d4c67e25a8f6a19a3f643bf92223765c | 9,692 | cpp | C++ | DFNs/Registration3D/IcpCC.cpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | 7 | 2019-02-26T15:09:50.000Z | 2021-09-30T07:39:01.000Z | DFNs/Registration3D/IcpCC.cpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | null | null | null | DFNs/Registration3D/IcpCC.cpp | H2020-InFuse/cdff | e55fd48f9a909d0c274c3dfa4fe2704bc5071542 | [
"BSD-2-Clause"
] | 1 | 2020-12-06T12:09:05.000Z | 2020-12-06T12:09:05.000Z | /**
* @author Alessandro Bianco
*/
/**
* @addtogroup DFNs
* @{
*/
#include "IcpCC.hpp"
#include <Converters/PointCloudToPclPointCloudConverter.hpp>
#include <Macros/YamlcppMacros.hpp>
#include <Errors/Assert.hpp>
#include <pcl/registration/icp.h>
#include <yaml-cpp/yaml.h>
#include <cloudcompare-core/PointCloud.h>
using namespace Converters;
using namespace PointCloudWrapper;
using namespace PoseWrapper;
using namespace CCLib;
namespace CDFF
{
namespace DFN
{
namespace Registration3D
{
IcpCC::IcpCC()
{
parameters = DEFAULT_PARAMETERS;
parametersHelper.AddParameter<ConvergenceType, ConvergenceTypeHelper>("GeneralParameters", "ConvergenceType", parameters.convergenceType, DEFAULT_PARAMETERS.convergenceType);
parametersHelper.AddParameter<double>("GeneralParameters", "MinimumErrorReduction", parameters.minimumErrorReduction, DEFAULT_PARAMETERS.minimumErrorReduction);
parametersHelper.AddParameter<int>("GeneralParameters", "MaximumNumberOfIterations", parameters.maximumNumberOfIterations, DEFAULT_PARAMETERS.maximumNumberOfIterations);
parametersHelper.AddParameter<bool>("GeneralParameters", "ScaleIsAdjustable", parameters.scaleIsAdjustable, DEFAULT_PARAMETERS.scaleIsAdjustable);
parametersHelper.AddParameter<bool>("GeneralParameters", "FarthestPointsAreFilteredOut", parameters.farthestPointsAreFilteredOut, DEFAULT_PARAMETERS.farthestPointsAreFilteredOut);
parametersHelper.AddParameter<int>("GeneralParameters", "SamplingLimit", parameters.samplingLimit, DEFAULT_PARAMETERS.samplingLimit);
parametersHelper.AddParameter<double>("GeneralParameters", "FinalOverlapRatio", parameters.finalOverlapRatio, DEFAULT_PARAMETERS.finalOverlapRatio);
parametersHelper.AddParameter<int>("GeneralParameters", "MaximumNumberOfThreads", parameters.maximumNumberOfThreads, DEFAULT_PARAMETERS.maximumNumberOfThreads);
configurationFilePath = "";
}
IcpCC::~IcpCC()
{
}
void IcpCC::configure()
{
parametersHelper.ReadFile(configurationFilePath);
ValidateParameters();
ConvertParametersToCCParametersList();
}
void IcpCC::process()
{
// Read data from input ports
if (GetNumberOfPoints(inSourceCloud) == 0 || GetNumberOfPoints(inSinkCloud) == 0)
{
outSuccess = false;
return;
}
CCLib::PointCloud *inputSourceCloud = Convert(&inSourceCloud);
CCLib::PointCloud *inputSinkCloud = Convert(&inSinkCloud);
// Process data
ValidateInputs(inputSourceCloud, inputSinkCloud);
ComputeTransform(inputSourceCloud, inputSinkCloud);
// Write data to output ports
// done in ComputeTransform, nothing to do here
// Cleanup
delete inputSourceCloud;
delete inputSinkCloud;
}
IcpCC::ConvergenceTypeHelper::ConvergenceTypeHelper(const std::string& parameterName, ConvergenceType& boundVariable, const ConvergenceType& defaultValue)
: ParameterHelper(parameterName, boundVariable, defaultValue)
{
}
IcpCC::ConvergenceType IcpCC::ConvergenceTypeHelper::Convert(const std::string& outputConvergenceType)
{
if (outputConvergenceType == "ErrorReduction" || outputConvergenceType == "0")
{
return MINIMUM_ERROR_REDUCTION;
}
else if (outputConvergenceType == "NumberOfIterations" || outputConvergenceType == "1")
{
return NUMBER_OF_ITERATIONS;
}
ASSERT(false, "Icp3D Error: unhandled convergence type: it should be either ErrorReduction or NumberOfIterations");
return MINIMUM_ERROR_REDUCTION;
}
const IcpCC::IcpOptionsSet IcpCC::DEFAULT_PARAMETERS =
{
/*.convergenceType =*/ MINIMUM_ERROR_REDUCTION,
/*.minimumErrorReduction =*/ 1e-5,
/*.maximumNumberOfIterations =*/ 20,
/*.scaleIsAdjustable =*/ false,
/*.farthestPointsAreFilteredOut =*/ false,
/*.samplingLimit =*/ 50000,
/*.finalOverlapRatio =*/ 1.0,
/*.maximumNumberOfThreads =*/ 0
};
void IcpCC::ConvertParametersToCCParametersList()
{
if (parameters.convergenceType == MINIMUM_ERROR_REDUCTION)
{
ccParametersList.convType = ICPRegistrationTools::MAX_ERROR_CONVERGENCE;
ccParametersList.minRMSDecrease = parameters.minimumErrorReduction;
}
else
{
ccParametersList.convType = ICPRegistrationTools::MAX_ITER_CONVERGENCE;
ccParametersList.nbMaxIterations = static_cast<unsigned>(parameters.maximumNumberOfIterations);
}
ccParametersList.adjustScale = parameters.scaleIsAdjustable;
ccParametersList.filterOutFarthestPoints = parameters.farthestPointsAreFilteredOut;
ccParametersList.samplingLimit = static_cast<unsigned>(parameters.samplingLimit);
ccParametersList.finalOverlapRatio = parameters.finalOverlapRatio;
ccParametersList.maxThreadCount = static_cast<unsigned>(parameters.maximumNumberOfThreads);
}
CCLib::PointCloud* IcpCC::Convert(PointCloudConstPtr cloud)
{
CCLib::PointCloud* ccCloud = new CCLib::PointCloud();
ccCloud->reserve( GetNumberOfPoints(*cloud) );
for (int pointIndex = 0; pointIndex < GetNumberOfPoints(*cloud); pointIndex++)
{
CCVector3 newPoint( GetXCoordinate(*cloud, pointIndex), GetYCoordinate(*cloud, pointIndex), GetZCoordinate(*cloud, pointIndex) );
ccCloud->addPoint(newPoint);
}
int fieldIndex = ccCloud->addScalarField("RegistrationDistances");
if (fieldIndex ==-1) {
ASSERT(true, "IcpCC error, it was not possible to add RegistrationDistances scalar field. Not enough memory?");
}
else {
ccCloud->setCurrentScalarField(fieldIndex);
}
return ccCloud;
}
// The required initial estimate/guess/output is the position of the source
// cloud's frame in the frame of the sink cloud. It is the inverse of the
// geometric transformation that brings the source cloud in the sink cloud.
RegistrationTools::ScaledTransformation IcpCC::ConvertTrasformToCCTransform(const Pose3D& transform)
{
RegistrationTools::ScaledTransformation ccTransform;
ccTransform.T.x = -GetXPosition(transform);
ccTransform.T.y = -GetYPosition(transform);
ccTransform.T.z = -GetZPosition(transform);
ccTransform.s = 1.0;
// We need this representation of the quaternion in order to use
// the method from CC that converts to a rotation matrix
double quaternion[4];
quaternion[0] = GetWOrientation(transform);
quaternion[1] = GetXOrientation(transform);
quaternion[2] = GetYOrientation(transform);
quaternion[3] = GetZOrientation(transform);
// Normalization, required for computing the rotation matrix
double norm = std::sqrt( quaternion[0]*quaternion[0] + quaternion[1]*quaternion[1] + quaternion[2]*quaternion[2] + quaternion[3]*quaternion[3]);
quaternion[0] = quaternion[0] / norm;
quaternion[1] = quaternion[1] / norm;
quaternion[2] = quaternion[2] / norm;
quaternion[3] = quaternion[3] / norm;
SquareMatrix rotationMatrix(3);
rotationMatrix.initFromQuaternion(quaternion);
ccTransform.R = rotationMatrix.inv();
return ccTransform;
}
Pose3D IcpCC::ConvertCCTransformToTranform(const RegistrationTools::ScaledTransformation& ccTransform)
{
ASSERT(ccTransform.s >= 0.99999 && ccTransform.s <= 1.00001, "IcpCC error, ccTransform does not have expected scale of 1");
Pose3D transform;
SetPosition(transform, -ccTransform.T.x, -ccTransform.T.y, -ccTransform.T.z);
// We need a non-cost matrix to call the toQuatenion method. (It is not expected indeed.)
SquareMatrix rotationMatrixCopy = ccTransform.R.inv();
double quaternion[4];
bool success = rotationMatrixCopy.toQuaternion(quaternion);
ASSERT(success, "IcpCC error, could not convert ccTransform rotation matrix to Transform quaternion");
SetOrientation(transform, quaternion[1], quaternion[2], quaternion[3], quaternion[0]);
return transform;
}
void IcpCC::ComputeTransform(CCLib::PointCloud* sourceCloud, CCLib::PointCloud* sinkCloud)
{
RegistrationTools::ScaledTransformation scaledTransform;
if (inUseGuess)
{
scaledTransform = ConvertTrasformToCCTransform(inTransformGuess);
}
else
{
scaledTransform.R = SquareMatrix(3);
scaledTransform.R.toIdentity();
scaledTransform.T.x = 0;
scaledTransform.T.y = 0;
scaledTransform.T.z = 0;
scaledTransform.s = 1.0;
}
double finalRMS;
unsigned finalPointCount;
ICPRegistrationTools::RESULT_TYPE result = ICPRegistrationTools::Register(sourceCloud, nullptr, sinkCloud, ccParametersList, scaledTransform, finalRMS, finalPointCount);
if (result == ICPRegistrationTools::ICP_APPLY_TRANSFO || result == ICPRegistrationTools::ICP_NOTHING_TO_DO)
{
outTransform = ConvertCCTransformToTranform(scaledTransform);
outSuccess = true;
}
else
{
outSuccess = false;
}
}
void IcpCC::ValidateParameters()
{
ASSERT(parameters.minimumErrorReduction > 0 || parameters.convergenceType != MINIMUM_ERROR_REDUCTION, "IcpCC Configuration error, Minimum Error Reduction has to be positive");
ASSERT(parameters.maximumNumberOfIterations > 0 || parameters.convergenceType != NUMBER_OF_ITERATIONS, "IcpCC Configuration error, Maximum number of iterations has to be positive");
ASSERT(parameters.samplingLimit > 0, "IcpCC Configuration error, Sampling limit has to be positive");
ASSERT(parameters.finalOverlapRatio >= 0 && parameters.finalOverlapRatio <= 1, "IcpCC Configuration error, finalOverlapRatio has to be between 0 and 1");
ASSERT(parameters.maximumNumberOfThreads >= 0, "IcpCC Configuration Error, maximumNumberOfThreads has to be greater or equal to zero");
}
void IcpCC::ValidateInputs(CCLib::PointCloud* sourceCloud, CCLib::PointCloud* sinkCloud)
{
ValidateCloud(sourceCloud);
ValidateCloud(sinkCloud);
}
void IcpCC::ValidateCloud(CCLib::PointCloud* cloud)
{
for (unsigned pointIndex = 0; pointIndex < cloud->size(); pointIndex++)
{
const CCVector3* point = cloud->getPoint(pointIndex);
ASSERT_EQUAL(point->x, point->x, "IcpCC Error, Cloud contains an NaN point");
ASSERT_EQUAL(point->y, point->y, "IcpCC Error, Cloud contains an NaN point");
ASSERT_EQUAL(point->z, point->z, "IcpCC Error, Cloud contains an NaN point");
}
}
}
}
}
/** @} */
| 36.02974 | 182 | 0.78343 | H2020-InFuse |
b397aaa9154a2bd8607974b463d6a39b7ad4a395 | 52 | hpp | C++ | include/tools/miniz.hpp | turgu1/ESP-IDF-Inkplate | 35840f1cbc73a155bbdd902ea78b78baa2257214 | [
"BSD-2-Clause"
] | 5 | 2021-02-10T15:01:14.000Z | 2022-03-08T00:43:43.000Z | include/tools/miniz.hpp | turgu1/ESP-IDF-Inkplate | 35840f1cbc73a155bbdd902ea78b78baa2257214 | [
"BSD-2-Clause"
] | 6 | 2021-03-02T16:36:38.000Z | 2022-01-14T19:40:53.000Z | include/tools/miniz.hpp | turgu1/ESP-IDF-Inkplate | 35840f1cbc73a155bbdd902ea78b78baa2257214 | [
"BSD-2-Clause"
] | 3 | 2021-01-28T08:04:13.000Z | 2021-08-12T23:33:33.000Z | #define MINIZ_HEADER_FILE_ONLY
#include "miniz.cpp"
| 17.333333 | 30 | 0.826923 | turgu1 |
b39838e6dc78b15bad220090324b10ad88b1a5a3 | 9,477 | cpp | C++ | Periodic_3_mesh_3/test/Periodic_3_mesh_3/test_implicit_shapes_bunch.cpp | ffteja/cgal | c1c7f4ad9a4cd669e33ca07a299062a461581812 | [
"CC0-1.0"
] | 3,227 | 2015-03-05T00:19:18.000Z | 2022-03-31T08:20:35.000Z | Periodic_3_mesh_3/test/Periodic_3_mesh_3/test_implicit_shapes_bunch.cpp | ffteja/cgal | c1c7f4ad9a4cd669e33ca07a299062a461581812 | [
"CC0-1.0"
] | 5,574 | 2015-03-05T00:01:56.000Z | 2022-03-31T15:08:11.000Z | Periodic_3_mesh_3/test/Periodic_3_mesh_3/test_implicit_shapes_bunch.cpp | ffteja/cgal | c1c7f4ad9a4cd669e33ca07a299062a461581812 | [
"CC0-1.0"
] | 1,274 | 2015-03-05T00:01:12.000Z | 2022-03-31T14:47:56.000Z | #include <CGAL/Periodic_3_mesh_3/config.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/make_periodic_3_mesh_3.h>
#include <CGAL/Periodic_3_mesh_3/IO/File_medit.h>
#include <CGAL/Periodic_3_mesh_triangulation_3.h>
#include <CGAL/Periodic_3_function_wrapper.h>
#include <CGAL/Labeled_mesh_domain_3.h>
#include <CGAL/Mesh_complex_3_in_triangulation_3.h>
#include <CGAL/Mesh_constant_domain_field_3.h>
#include <CGAL/Mesh_criteria_3.h>
#include <CGAL/array.h>
#include <CGAL/number_type_config.h> // CGAL_PI
#include <cmath>
#include <fstream>
#include <iostream>
#include <sstream>
// Kernel
typedef CGAL::Exact_predicates_inexact_constructions_kernel K;
typedef K::FT FT;
typedef K::Point_3 Point;
typedef K::Iso_cuboid_3 Iso_cuboid;
// Domain
typedef FT (Function)(const Point&);
// the wrapper is needed because not all the functions are triply periodic
typedef CGAL::Periodic_3_function_wrapper<Function, K> Periodic_function;
typedef CGAL::Labeled_mesh_domain_3<K> Periodic_mesh_domain;
// Triangulation
typedef CGAL::Periodic_3_mesh_triangulation_3<Periodic_mesh_domain>::type Tr;
typedef CGAL::Mesh_complex_3_in_triangulation_3<Tr> C3t3;
// Criteria
typedef CGAL::Mesh_criteria_3<Tr> Periodic_mesh_criteria;
// To avoid verbose function and named parameters call
using namespace CGAL::parameters;
// Function
FT sphere(const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
return CGAL::squared_distance(p, Point(0.5, 0.5, 0.5))-0.2;
}
FT schwarz_p(const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT x2 = std::cos( p.x() * 2 * CGAL_PI ),
y2 = std::cos( p.y() * 2 * CGAL_PI ),
z2 = std::cos( p.z() * 2 * CGAL_PI );
return x2 + y2 + z2;
}
// not triply periodic
FT scherk(const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
return std::exp( p.z() ) * std::cos( p.y() * 2 * CGAL_PI) - std::cos( p.x() * 2 * CGAL_PI );
}
// Triply Implicit Periodic Functions for meshing
FT schwarz_p_transl (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT x2 = std::cos(p.x() * 2 * CGAL_PI + CGAL_PI / 2.0),
y2 = std::cos(p.y() * 2 * CGAL_PI + CGAL_PI / 2.0),
z2 = std::cos(p.z() * 2 * CGAL_PI + CGAL_PI / 2.0);
return x2 + y2 + z2;
}
FT gyroid (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
return cx * sy + cy * sz + cz * sx;
}
FT diamond (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
return sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz;
}
FT double_p (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT c2x = std::cos(2 * p.x() * 2 * CGAL_PI),
c2y = std::cos(2 * p.y() * 2 * CGAL_PI),
c2z = std::cos(2 * p.z() * 2 * CGAL_PI);
return 0.5 * (cx * cy + cy * cz + cz * cx ) + 0.2 * (c2x + c2y + c2z);
}
FT G_prime (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT c2x = std::cos(2 * p.x() * 2 * CGAL_PI),
c2y = std::cos(2 * p.y() * 2 * CGAL_PI),
c2z = std::cos(2 * p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
const FT s2x = std::sin(2 * p.x() * 2 * CGAL_PI),
s2y = std::sin(2 * p.y() * 2 * CGAL_PI),
s2z = std::sin(2 * p.z() * 2 * CGAL_PI);
return 5 * (s2x * sz * cy + s2y * sx * cz + s2z * sy * cx)
+ 1 * (c2x * c2y + c2y * c2z + c2z * c2x);
}
FT lidinoid (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT c2x = std::cos(2 * p.x() * 2 * CGAL_PI),
c2y = std::cos(2 * p.y() * 2 * CGAL_PI),
c2z = std::cos(2 * p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
const FT s2x = std::sin(2 * p.x() * 2 * CGAL_PI),
s2y = std::sin(2 * p.y() * 2 * CGAL_PI),
s2z = std::sin(2 * p.z() * 2 * CGAL_PI);
return 1 * (s2x * sz * cy + s2y * sx * cz + s2z * sy * cx)
- 1 * (c2x * c2y + c2y * c2z + c2z * c2x) + 0.3;
}
FT D_prime (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT c2x = std::cos(2 * p.x() * 2 * CGAL_PI),
c2y = std::cos(2 * p.y() * 2 * CGAL_PI),
c2z = std::cos(2 * p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
return 1 * ( sx * sy * sz) + 1 * ( cx * cy * cz)
- 1 * ( c2x * c2y + c2y * c2z + c2z * c2x) - 0.4;
}
FT split_p (const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT cx = std::cos(p.x() * 2 * CGAL_PI),
cy = std::cos(p.y() * 2 * CGAL_PI),
cz = std::cos(p.z() * 2 * CGAL_PI);
const FT c2x = std::cos(2 * p.x() * 2 * CGAL_PI),
c2y = std::cos(2 * p.y() * 2 * CGAL_PI),
c2z = std::cos(2 * p.z() * 2 * CGAL_PI);
const FT sx = std::sin(p.x() * 2 * CGAL_PI),
sy = std::sin(p.y() * 2 * CGAL_PI),
sz = std::sin(p.z() * 2 * CGAL_PI);
const FT s2x = std::sin(2 * p.x() * 2 * CGAL_PI),
s2y = std::sin(2 * p.y() * 2 * CGAL_PI),
s2z = std::sin(2 * p.z() * 2 * CGAL_PI);
return 1.1 * (s2x * sz * cy + s2y * sx * cz + s2z * sy * cx)
- 0.2 * (c2x * c2y + c2y * c2z + c2z * c2x)
- 0.4 * (cx + cy + cz);
}
FT cylinder(const Point& p)
{
assert(p.x() >= 0 && p.y() >= 0 && p.z() >= 0 && p.x() < 1 && p.y() < 1 && p.z() < 1);
const FT x2 = (p.y() - 0.5) * (p.y() - 0.5),
y2 = (p.z() - 0.5) * (p.z() - 0.5);
return x2 + y2 - 0.1;
}
typedef CGAL::Mesh_constant_domain_field_3<Periodic_mesh_domain::R,
Periodic_mesh_domain::Index> Sizing_field;
int main()
{
int domain_size = 1;
Iso_cuboid canonical_cube(0, 0, 0, domain_size, domain_size, domain_size);
// Array of the functions
const int functions_count = 11;
std::array<Periodic_function, functions_count> implicit_functions =
{{
Periodic_function(cylinder, canonical_cube),
Periodic_function(D_prime, canonical_cube),
Periodic_function(diamond, canonical_cube),
Periodic_function(double_p, canonical_cube),
Periodic_function(G_prime, canonical_cube),
Periodic_function(gyroid, canonical_cube),
Periodic_function(lidinoid, canonical_cube),
Periodic_function(scherk, canonical_cube),
Periodic_function(schwarz_p, canonical_cube),
Periodic_function(sphere, canonical_cube),
Periodic_function(split_p, canonical_cube)
}};
for(int i=0; i<functions_count; ++i)
{
// Periodic mesh domain
Periodic_mesh_domain domain =
Periodic_mesh_domain::create_implicit_mesh_domain(
implicit_functions[i], canonical_cube);
// Mesh criteria
Periodic_mesh_criteria criteria(facet_angle = 30,
facet_size = 0.05,
facet_distance = 0.025,
cell_radius_edge = 2,
cell_size = 0.05);
// Mesh generation
std::cout << "Meshing implicit shape n°: " << i << std::endl;
C3t3 c3t3 = CGAL::make_periodic_3_mesh_3<C3t3>(domain, criteria);
// File name
std::stringstream index;
index << i;
std::string file_name = "output_implicit_shape_" + index.str() + ".mesh";
// Output
std::ofstream medit_file(file_name.c_str());
CGAL::IO::output_periodic_mesh_to_medit(medit_file, c3t3);
}
std::cout << "EXIT SUCCESS" << std::endl;
return 0;
}
| 37.458498 | 94 | 0.514825 | ffteja |
b398ad589a62dedfddbf142c217685d2e62e42d6 | 330 | cpp | C++ | acmicpc/15988.cpp | juseongkr/BOJ | 8f10a2bf9a7d695455493fbe7423347a8b648416 | [
"Apache-2.0"
] | 7 | 2020-02-03T10:00:19.000Z | 2021-11-16T11:03:57.000Z | acmicpc/15988.cpp | juseongkr/Algorithm-training | 8f10a2bf9a7d695455493fbe7423347a8b648416 | [
"Apache-2.0"
] | 1 | 2021-01-03T06:58:24.000Z | 2021-01-03T06:58:24.000Z | acmicpc/15988.cpp | juseongkr/Algorithm-training | 8f10a2bf9a7d695455493fbe7423347a8b648416 | [
"Apache-2.0"
] | 1 | 2020-01-22T14:34:03.000Z | 2020-01-22T14:34:03.000Z | #include <iostream>
using namespace std;
#define MAX 1000001
#define MOD 1000000009
long long dp[MAX];
int main()
{
int t, n;
dp[0] = dp[1] = 1;
dp[2] = 2;
dp[3] = 4;
for (int i=4; i<MAX; ++i)
dp[i] += (dp[i-1] + dp[i-2] + dp[i-3]) % MOD;
cin >> t;
while (t--) {
cin >> n;
cout << dp[n] << '\n';
}
return 0;
}
| 12.692308 | 47 | 0.506061 | juseongkr |
b39b83fb2a52e3e50856df9ebe82d809dbd310c1 | 1,459 | cpp | C++ | Rare Topics/Rare Problems/Bracket Matching/Nesting a Bunch of Brackets.cpp | satvik007/uva | 72a763f7ed46a34abfcf23891300d68581adeb44 | [
"MIT"
] | 3 | 2017-08-12T06:09:39.000Z | 2018-09-16T02:31:27.000Z | Rare Topics/Rare Problems/Bracket Matching/Nesting a Bunch of Brackets.cpp | satvik007/uva | 72a763f7ed46a34abfcf23891300d68581adeb44 | [
"MIT"
] | null | null | null | Rare Topics/Rare Problems/Bracket Matching/Nesting a Bunch of Brackets.cpp | satvik007/uva | 72a763f7ed46a34abfcf23891300d68581adeb44 | [
"MIT"
] | null | null | null | #include <cstdio>
#include <stack>
#include <cstring>
#include <iostream>
using namespace std;
stack<char> checker;
bool isOpening(char c) {
if (c == '(' || c == '[' || c == '<' || c == '{')
return true;
return false;
}
bool isClosing(char c) {
if (c == ')' || c == ']' || c == '>' || c == '}')
return true;
return false;
}
int main() {
char s[3001];
while (gets(s)) {
int count = 0;
int len = strlen(s), i;
for (i = 0; i < len; i++) {
count++;
if (isOpening(s[i])) {
if (s[i] == '(' && s[i + 1] == '*') {
checker.push('*');
i++;
} else {
checker.push(s[i]);
}
} else if (isClosing(s[i]) || (s[i] == '*' && s[i + 1] == ')')) {
if (checker.empty())
break;
if (s[i] == '*') {
if (checker.top() != '*') {
break;
}
checker.pop();
i++;
} else if (s[i] == ')') {
if (checker.top() != '(') {
break;
}
checker.pop();
} else if (s[i] == ']') {
if (checker.top() != '[') {
break;
}
checker.pop();
} else if (s[i] == '>') {
if (checker.top() != '<') {
break;
}
checker.pop();
} else if (s[i] == '}') {
if (checker.top() != '{') {
break;
}
checker.pop();
}
}
}
if (i < len || !checker.empty()) {
if (i>=len && !checker.empty())
count++;
printf("NO %d\n", count);
} else
printf("YES\n");
while (!checker.empty())
checker.pop();
}
return 0;
} | 18.2375 | 68 | 0.416038 | satvik007 |
b3a57c4d501febc063f875cc4cfdc5fff137aeb3 | 15,855 | cc | C++ | mindspore/ccsrc/distributed/collective/collective_manager.cc | httpsgithu/mindspore | c29d6bb764e233b427319cb89ba79e420f1e2c64 | [
"Apache-2.0"
] | 1 | 2022-02-23T09:13:43.000Z | 2022-02-23T09:13:43.000Z | mindspore/ccsrc/distributed/collective/collective_manager.cc | 949144093/mindspore | c29d6bb764e233b427319cb89ba79e420f1e2c64 | [
"Apache-2.0"
] | null | null | null | mindspore/ccsrc/distributed/collective/collective_manager.cc | 949144093/mindspore | c29d6bb764e233b427319cb89ba79e420f1e2c64 | [
"Apache-2.0"
] | null | null | null | /**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "distributed/collective/collective_manager.h"
#include <algorithm>
#include <string>
#include <vector>
#include <functional>
#include <csignal>
#include <memory>
#include "utils/ms_context.h"
#include "distributed/recovery/recovery_context.h"
namespace mindspore {
namespace distributed {
namespace collective {
using recovery::RecoveryContext;
CollectiveManager::CollectiveManager()
: inited_(false),
finalized_(true),
need_reinit_(false),
host_ctx_(nullptr),
device_ctx_(nullptr),
host_comm_lib_instance_(nullptr),
device_comm_lib_instance_(nullptr),
global_rank_id_(0),
local_rank_id_(0),
global_rank_size_(0),
global_group_ranks_({}) {}
CollectiveManager::~CollectiveManager() {
if (!finalized_) {
try {
(void)Finalize();
} catch (std::exception &) {
MS_LOG(ERROR) << "Failed to finalize collective manager.";
}
}
finalized_ = true;
host_ctx_ = nullptr;
device_ctx_ = nullptr;
host_comm_lib_instance_ = nullptr;
device_comm_lib_instance_ = nullptr;
}
std::shared_ptr<CollectiveManager> CollectiveManager::instance() {
static std::shared_ptr<CollectiveManager> instance = nullptr;
if (instance == nullptr) {
instance.reset(new (std::nothrow) CollectiveManager());
MS_EXCEPTION_IF_NULL(instance);
}
return instance;
}
namespace {
// The wrapper to provide a timeout mechanism for executing functions.
bool ExecuteFuncInThread(const std::function<bool()> &func, const int64_t timeout) {
bool execute_success = false;
bool execute_fail = false;
std::mutex exec_ret_mutex;
std::condition_variable thread_blocker;
std::unique_ptr<std::thread> executive_thread = std::make_unique<std::thread>([&] {
if (!func()) {
MS_LOG(ERROR) << "Failed to execute function asynchronously";
std::unique_lock<std::mutex> lock(exec_ret_mutex);
execute_fail = true;
thread_blocker.notify_one();
return;
}
{
std::unique_lock<std::mutex> lock(exec_ret_mutex);
execute_success = true;
thread_blocker.notify_one();
}
});
executive_thread->detach();
std::unique_lock<std::mutex> locker(exec_ret_mutex);
(void)thread_blocker.wait_for(locker, std::chrono::seconds(timeout), [&] { return execute_success || execute_fail; });
if (!execute_success && !execute_fail) {
std::string node_id = common::GetEnv("MS_NODE_ID");
#if !defined(_WIN32) && !defined(_WIN64)
MS_LOG(ERROR) << "Execute function asynchronously timeout, node id: " << node_id << " exit process";
(void)kill(getpid(), SIGTERM);
#endif
}
return execute_success;
}
// In a disaster recovery scenario, the comparison between the current unique id and the last generated unique id
// ensures that the acquired unique id is newly generated, and the latest unique id will be persisted.
bool CheckUniqueIDLatest(const std::string &group_name, size_t root_info_size, const void *root_info) {
MS_EXCEPTION_IF_NULL(root_info);
auto persistent_json = RecoveryContext::GetInstance()->persistent_json();
MS_EXCEPTION_IF_NULL(persistent_json);
std::string new_unique_id(static_cast<const char *>(root_info), root_info_size);
std::vector<int> new_unique_id_integer_seq;
(void)std::transform(new_unique_id.begin(), new_unique_id.end(), std::back_inserter(new_unique_id_integer_seq),
[](char c) { return static_cast<int>(c); });
const char unique_id_str[] = "_unique_id";
std::string unique_id_key = group_name + unique_id_str;
if (!persistent_json->Exists(unique_id_key)) {
persistent_json->Insert(unique_id_key, new_unique_id_integer_seq);
return true;
}
std::vector<int> old_unique_id_integer_seq = persistent_json->Get<std::vector<int>>(unique_id_key);
if (new_unique_id_integer_seq == old_unique_id_integer_seq) {
return false;
}
persistent_json->Insert(unique_id_key, new_unique_id_integer_seq);
return true;
}
} // namespace
bool CollectiveManager::Initialize() {
if (inited_ && !need_reinit_) {
return true;
}
device_type_ = MsContext::GetInstance()->get_param<std::string>(MS_CTX_DEVICE_TARGET);
MS_LOG(INFO) << "Start initializing collective communication for backend: " << device_type_ << "...";
// Step 1: Initialize host side collective communication.
if (!InitHostCommlib()) {
MS_LOG(ERROR) << "Failed to initialize host communication library.";
return false;
}
// Step 2, 3 and 4 are for device communication library. So if the training job is only launched on CPU, they will not
// be necessary.
// Step 2: Assign local rank id(device id) for this process.
if (!AssignLocalRank()) {
MS_LOG(ERROR) << "Failed to assign local rank id.";
return false;
}
// Step 3: Initialize device side collective communication.
if (!InitDeviceCommLib()) {
MS_LOG(ERROR) << "Failed to initialize device communication library.";
return false;
}
// Step 4: Create global communication group.
MS_EXCEPTION_IF_NULL(device_comm_lib_instance_);
if (!CreateCommunicationGroup(device_comm_lib_instance_->global_group_name(), global_group_ranks_)) {
MS_LOG(ERROR) << "Failed to create group " << device_comm_lib_instance_->global_group_name();
return false;
}
MS_LOG(INFO) << "End initializing collective communication for backend: " << device_type_;
inited_ = true;
finalized_ = false;
need_reinit_ = false;
return true;
}
bool CollectiveManager::CreateCommunicationGroup(const std::string &group_name,
const std::vector<uint32_t> &group_ranks) {
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
MS_EXCEPTION_IF_NULL(device_comm_lib_instance_);
// Step 1: Create communication group on host side if.
if (!host_comm_lib_instance_->CreateCommunicationGroup(group_name, group_ranks)) {
MS_LOG(ERROR) << "Failed to create communication group " << group_name << " on host side.";
return false;
}
// Step 2: Create communication group on device side.
if (!device_comm_lib_instance_->CreateCommunicationGroup(group_name, group_ranks)) {
MS_LOG(ERROR) << "Failed to create communication group " << group_name << " on device side.";
return false;
}
// Step 3: Generate device information of the root node.
CommunicationGroupPtr group = device_comm_lib_instance_->GetGroup(group_name);
MS_EXCEPTION_IF_NULL(group);
size_t root_info_size = 0;
void *root_info = group->GenerateRootInfo(&root_info_size);
MS_EXCEPTION_IF_NULL(root_info);
bool ret = false;
// Step 4: Broadcast the device root information to all nodes on host side.
while (!ret) {
ret = host_comm_lib_instance_->BroadcastUniqueID(group_name, root_info_size, root_info);
if (!ret) {
MS_LOG(ERROR) << "Broadcast for device root info failed on the host side.";
return false;
}
// In disaster recovery scenarios, it is necessary to ensure that the unique id obtained from the Scheduler is a
// newly generated one.
if (RecoveryContext::GetInstance()->enable_recovery()) {
ret = CheckUniqueIDLatest(group_name, root_info_size, root_info);
if (!ret) {
// The time interval for querying latest unique id from scheduler: 3 second.
constexpr uint32_t kWaitDuration = 3;
std::this_thread::sleep_for(std::chrono::seconds(kWaitDuration));
}
}
}
// Step 5: Initialize communication group on the device side.
std::function<bool()> init_device_comm_group_func = [&, this]() {
device_ctx_->Initialize();
return group->Initialize(root_info);
};
MS_LOG(INFO) << "Begin initialize communication group on the device side.";
// Timeout limit 180 seconds to wait finish initializing device communication group.
const int64_t kTimeToWait = 180;
// Initialize communication group on the device side in thread with timeout limit.
ret = ExecuteFuncInThread(init_device_comm_group_func, kTimeToWait);
MS_LOG(INFO) << "End initialize communication group on the device side.";
return ret;
}
bool CollectiveManager::DestroyCommunicationGroup(const std::string &group_name) {
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
if (!host_comm_lib_instance_->DestroyCommunicationGroup(group_name)) {
MS_LOG(ERROR) << "Failed to destroy communication group of " << group_name << " on the host side.";
return false;
}
MS_EXCEPTION_IF_NULL(device_comm_lib_instance_);
if (!device_comm_lib_instance_->DestroyCommunicationGroup(group_name)) {
MS_LOG(ERROR) << "Failed to destroy communication group of " << group_name << " on the device side.";
return false;
}
return true;
}
uint32_t CollectiveManager::GetRankId(const std::string &group_name) {
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
return host_comm_lib_instance_->GetRankId(group_name);
}
uint32_t CollectiveManager::GetGroupSize(const std::string &group_name) {
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
return host_comm_lib_instance_->GetGroupSize(group_name);
}
bool CollectiveManager::Finalize() {
if (!inited_.load() || finalized_.load()) {
return true;
}
std::function<bool()> finalize_func = [&, this]() {
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
if (!host_comm_lib_instance_->Finalize()) {
MS_LOG(WARNING) << "Failed to finalize host communication library.";
}
MS_EXCEPTION_IF_NULL(device_comm_lib_instance_);
if (!device_comm_lib_instance_->Finalize()) {
MS_LOG(WARNING) << "Failed to finalize device communication library.";
}
inited_ = false;
finalized_ = true;
return true;
};
MS_LOG(INFO) << "Begin finalize collective manager.";
// Timeout limit 5 seconds to wait to finish finalizing device communication group.
const int64_t kTimeToWait = 5;
// Finalize collective manager in thread with timeout limit.
bool ret = ExecuteFuncInThread(finalize_func, kTimeToWait);
MS_LOG(INFO) << "End finalize collective manager.";
return ret;
}
void CollectiveManager::set_global_rank_id(uint32_t global_rank_id) { global_rank_id_ = global_rank_id; }
void CollectiveManager::set_global_rank_size(uint32_t global_rank_size) { global_rank_size_ = global_rank_size; }
uint32_t CollectiveManager::local_rank_id() const { return local_rank_id_; }
bool CollectiveManager::InitHostCommlib() {
device::DeviceContextKey host_key = {"CPU", 0};
host_ctx_ = device::DeviceContextManager::GetInstance().GetOrCreateDeviceContext(host_key);
MS_EXCEPTION_IF_NULL(host_ctx_);
if (!host_ctx_->LoadCollectiveCommLib()) {
MS_LOG(ERROR) << "Failed to load communication library on the host side.";
return false;
}
host_comm_lib_instance_ = host_ctx_->collective_comm_lib();
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
// For some communication libraries, global_rank_id_', 'global_rank_size_' should be set by caller, e.g., when using
// MindSpore communication. For other communication libraries, global rank id and size is generated by itself, e.g.,
// OpenMPI, and parameters 'global_rank_id_', 'global_rank_size_' will not be used.
MS_LOG(INFO) << "Start initializing communication library on host side...";
if (!host_comm_lib_instance_->Initialize(global_rank_id_, global_rank_size_)) {
MS_LOG(ERROR) << "Failed to initialize communication library on host side.";
return false;
}
if (!global_group_ranks_.empty()) {
global_group_ranks_.clear();
}
// Reassign 'global_rank_id_' and 'global_rank_size_'. Generate global communication group ranks.
global_rank_id_ = host_comm_lib_instance_->global_rank_id();
global_rank_size_ = host_comm_lib_instance_->global_rank_size();
for (uint32_t i = 0; i < global_rank_size_; i++) {
global_group_ranks_.push_back(i);
}
// Create world group on host side for AllGather operation of host name while assigning local rank.
host_global_group_name_ = host_comm_lib_instance_->global_group_name();
if (!host_comm_lib_instance_->CreateCommunicationGroup(host_global_group_name_, global_group_ranks_)) {
MS_LOG(ERROR) << "Failed to create communication group " << host_global_group_name_ << " on host side.";
return false;
}
MS_LOG(INFO) << "Communication library on host side is successfully initialized. Global rank id: " << global_rank_id_
<< ", global rank size: " << global_rank_size_;
return true;
}
bool CollectiveManager::InitDeviceCommLib() {
device::DeviceContextKey device_key = {device_type_, local_rank_id_};
device_ctx_ = device::DeviceContextManager::GetInstance().GetOrCreateDeviceContext(device_key);
MS_EXCEPTION_IF_NULL(device_ctx_);
// We can initialize device context now because device id(local_rank_id_) is already assigned.
device_ctx_->Initialize();
if (!device_ctx_->LoadCollectiveCommLib()) {
MS_LOG(ERROR) << "Failed to load communication library on the device side.";
return false;
}
device_comm_lib_instance_ = device_ctx_->collective_comm_lib();
MS_EXCEPTION_IF_NULL(device_comm_lib_instance_);
MS_LOG(INFO) << "Start initializing communication library on device side...";
if (!device_comm_lib_instance_->Initialize(global_rank_id_, global_rank_size_)) {
MS_LOG(ERROR) << "Failed to initialize communication library on device side.";
return false;
}
MS_LOG(INFO) << "Communication library on device side is successfully initialized.";
return true;
}
bool CollectiveManager::AssignLocalRank() {
char host_name[MAX_HOSTNAME_LEN] = {0};
#ifndef _WIN32
if (gethostname(host_name, MAX_HOSTNAME_LEN) != 0) {
MS_LOG(ERROR) << "Failed to get host name.";
return false;
}
#endif
MS_LOG(INFO) << "Host name for rank " << global_rank_id_ << " is " << host_name;
// Generate host name hash for every process. The host names of different physical machine should not be the same so
// that local rank id won't repeat.
size_t host_hash = std::hash<std::string>()(host_name);
const uint32_t kGlobalRankSize = global_rank_size_;
std::vector<size_t> all_host_hashs(kGlobalRankSize);
if (global_rank_id_ >= global_rank_size_) {
MS_LOG(ERROR) << "The global rank id " << global_rank_id_ << " should be less than global rank size "
<< global_rank_size_;
return false;
}
all_host_hashs[global_rank_id_] = host_hash;
MS_EXCEPTION_IF_NULL(host_comm_lib_instance_);
if (!host_comm_lib_instance_->AllGatherHostHashName(host_hash, &all_host_hashs)) {
MS_LOG(ERROR) << "AllGather for host names failed.";
return false;
}
// Accumulate rank id.
// In disaster recovery scenario, this function will enter multiple times when the network is reconfigured, so old
// local rank id need to be cleaned.
local_rank_id_ = 0;
for (uint32_t rank = 0; rank < global_rank_size_; rank++) {
if (rank == global_rank_id_) {
break;
}
if (all_host_hashs[rank] == all_host_hashs[global_rank_id_]) {
local_rank_id_++;
}
}
MsContext::GetInstance()->set_param<uint32_t>(MS_CTX_DEVICE_ID, local_rank_id_);
MS_LOG(INFO) << "The local rank id assigned for this process is " << local_rank_id_
<< ". device_id of ms_context is set.";
return true;
}
} // namespace collective
} // namespace distributed
} // namespace mindspore
| 38.021583 | 120 | 0.728414 | httpsgithu |
b3a6df7e45db6d968224ef43935f8fb5546c1740 | 8,399 | cc | C++ | src/HSLib/HSacquire.cc | pygamma-mrs/gamma | c83a7c242c481d2ecdfd49ba394fea3d5816bccb | [
"BSD-3-Clause"
] | 4 | 2021-03-15T10:02:13.000Z | 2022-01-16T11:06:28.000Z | src/HSLib/HSacquire.cc | pygamma-mrs/gamma | c83a7c242c481d2ecdfd49ba394fea3d5816bccb | [
"BSD-3-Clause"
] | 1 | 2022-01-27T15:35:03.000Z | 2022-01-27T15:35:03.000Z | src/HSLib/HSacquire.cc | pygamma-mrs/gamma | c83a7c242c481d2ecdfd49ba394fea3d5816bccb | [
"BSD-3-Clause"
] | null | null | null | /* HSacquire.cc *************************************************-*-c++-*-
** **
** G A M M A **
** **
** Hilbert Space Acquisitions Implementation **
** **
** Copyright (c) 1990, 1991, 1992 **
** Tilo Levante, Scott Smith **
** Eidgenoessische Technische Hochschule **
** Labor fuer physikalische Chemie **
** 8092 Zurich / Switzerland **
** **
** $Header: $
** **
*************************************************************************/
/*************************************************************************
** **
** Description **
** **
** The GAMMA Platform Provides Functions for Simulation of Magnetic **
** Resonance Experiments and Other Associated Mathematical **
** Capabilities. The Set of Functions Herein Allow for the Simulation **
** of Free Induction Decays(FID's) in Spin Hilbert Space & Adds **
** Abilities Related To Simulated Data Acquistion. **
** **
*************************************************************************/
#ifndef HSacquire_cc_ // Is file already included?
# define HSacquire_cc_ 1 // If no, then remember it
# if defined(GAMPRAGMA) // Using the GNU compiler?
# pragma implementation // This is the implementation
# endif
#include <HSLib/HSacquire.h> // Include the file header
#include <Matrix/row_vector.h> // Knowledge of row vectors
#include <HSLib/GenOp.h> // Knowledge of operators
//#include <HSLib/HSprop.h> // Knowledge of nmr evolutions
#include <Basics/Gconstants.h> // Knowledge of PI
// ____________________________________________________________________________
// A Generic Free Induction Decays
// ____________________________________________________________________________
/* These functions fill up a row vector with a Free Induction Decay (FID) based
upon an initial density operator representing the initial state of the spin
system evolving under a static Hamiltonian. The user specifies the property
detected (usually transverse magnetization) as well as the time between FID
points (dwell time). Note that the acquire1D class will also generate FID's
(see the Level 1 Module in GAMMA) but is much more flexible. Also note that
if one intends to apply a Fourier transform to the generated FID it should
have a point size that is base 2 (e.g. 2048, 4096, .....)
Input sig0 : Operator propagated (initial dens. op.)
D : Detection operator in trace computation
H : Hamiltonian for propagation (in Hertz)
U : Propagator for one increment
td : Dwell time (seconds, per point)
N : Number of FID points generated
fid : Data vector containing the result
Output : None, FID data vector filled
Note : Assumed fid is at least as large as N
Note : Propagator is unitless, so 2*PI factor
used to get radians in exponent
Note : If no block size is specified it will
be taken as the vector size
Note : If no vector is specified on will be
generated and returned */
void acquire(gen_op& S, gen_op& D, gen_op& H, double T, int N, row_vector& F, double CO)
{ FID(S,D,H,T,N,F,CO); }
void acquire(gen_op& sig0 , gen_op& D, gen_op& U, int N, row_vector& fid, double CO)
{ FID(sig0, D, U, 0, N, fid, CO); }
// This function was declared, but not defined, before 2011.05.16 (DCT)
void acquire(gen_op& sig0, gen_op& D, HSprop& Hp, int N, row_vector& fid, double CO)
{ FID(sig0, D, Hp, N, fid, CO); }
void FID(gen_op& sig0, gen_op& D, gen_op& H, double td, int N, row_vector& fid, double CO)
{
if(fid.size() < N) fid=row_vector(N); // Insure block is large enough
H.set_EBR(); // First put H into its eigenbase
sig0.Op_base(H); // Next put sig0 into eigenbase of H
D.Op_base(H); // Put detection op. to eigenbase of H
complex z(0,-PIx2*td); // Exponential factor for H -> U
gen_op U; // Propagator for evolution
if(td) U = (z*H).exp(); // Set the td evolution propagator
else U = H; // If td = 0, assume U was input
int hs = dim(H); // Hilbert space dimension
int ls = hs*hs; // Liouville space dimension
complex *A = new complex[ls]; // Array for A(p)
complex *B = new complex[ls]; // Array for B(p)
int i,j,pos;
for(pos=0,i=0; i<hs; i++) // Generate the A & B arrays
for(j=0; j<hs; j++) // We'll only count non-zero
{ // contributors to acquisition
A[pos] = D(i,j)*sig0(j,i);
B[pos] = conj(U(i,i), U(j,j));
if(square_norm(A[pos])>CO) // Use elements if trace contribution
pos ++;
}
for(int k=0; k<N; k++) // Loop over desired points (& times)
{
z = 0; // Begin with zero point
for(int p=0; p<pos; p++) // Loop over point contributors
{
z += A[p]; // Add contribution from p
A[p] *= B[p]; // k+1
} // Adjust A so its really A*B
fid.put(z,k); // Set point, move to next k (time)
}
delete [] A; // Delete complex array A
delete [] B; // Delete complex array B
}
void FID(gen_op& sig0 , gen_op& D, gen_op& U, int N, row_vector& fid, double CO)
{ FID(sig0, D, U, 0, N, fid, CO); }
void FID(gen_op& sig0 , gen_op& D, HSprop& U, int N, row_vector& fid, double CO)
{ gen_op UOp = U.Op(); FID(sig0, D, UOp, 0, N, fid, CO); }
row_vector acquire(gen_op& sig0 , gen_op& D, gen_op& H, double td, int N, double CO)
{ row_vector data(N); FID(sig0,D,H,td,N,data,CO); return data; }
row_vector acquire(gen_op& sig0 , gen_op& D, gen_op& U, int N, double CO)
{ row_vector data(N); FID(sig0,D,U,0,N,data,CO); return data; }
// This function was declared, but not defined, before 2011.05.16 (DCT)
row_vector acquire(gen_op& sig0, gen_op& D, HSprop& Hp, int N, double CO)
{ row_vector data(N); FID(sig0,D,Hp,N,data,CO); return data; }
row_vector FID(gen_op& sig0 , gen_op& D, gen_op& H, double td, int N, double CO)
{ row_vector data(N); FID(sig0,D,H,td,N,data,CO); return data; }
row_vector FID(gen_op& sig0 , gen_op& D, gen_op& U, int N, double CO)
{ row_vector data(N); FID(sig0,D,U,0,N,data,CO); return data; }
row_vector FID(gen_op& sig0 , gen_op& D, HSprop& U, int N, double CO)
{ row_vector data(N); gen_op UOp=U.Op(); FID(sig0,D,UOp,0,N,data,CO); return data; }
// ____________________________________________________________________________
// B Acquisiton Generation Output Functions
// ____________________________________________________________________________
/* This functions exist primarly to check the acquisition functions found
earlier in this file. They will simply print output aspects of the
calculation used for the specified input parameters. */
// ____________________________________________________________________________
// Z Free Induction Decay Applied Theory
// ____________________________________________________________________________
/* We will work in the eigenbasis of the propergator U, where U is generated
from the static Hamiltonian H as
-2*pi*i*H*td
U = e
Both U and H are represented by diagonal matrices in this eigenbasis and
since H is Hermtitian, U will be unitary (adjoint == inverse). An
acquisition point k, which corresponds to time t = k*td, is given by
fid(k) = Trace { D * sigma(t) }
k k
= Trace { D * U (td) * sig0 * adjoint[U (td)] }
k k
= Sum i,j { <i|D|j><j|U (td)|j>*<j|sig0|i>*conj(<i|U (td)|i>) }
k
= Sum i,j { <i|D|j><j|sig0|i> * [<j|U|j>*conj(<i|U|i>)] }
k k
= Sum i,j { A(i,j) * B(i,j) } = Sum p { A(p) * B (p) }
The FID functions all implement the last form for generating a series
of expectation values evenly incremented in time. The routines will
immediately generate the arrays A and B then quicky do the sum. The
points are repeatly generated by taking powers of B elements. */
#endif // HSacquire.cc
| 43.744792 | 90 | 0.596142 | pygamma-mrs |
b3a725bbdf3f0fa6de92e4559ce92656326f8842 | 1,039 | cpp | C++ | Chapter_4_Mathematical_Logical_Bitwise_and_Shift_Operators/Program16.cpp | othneildrew/CPP-Programming-Practices | 27a20c00b395446a7d2e0dd4b199f4cd9e35591b | [
"MIT"
] | 1 | 2020-12-03T15:26:20.000Z | 2020-12-03T15:26:20.000Z | Chapter_4_Mathematical_Logical_Bitwise_and_Shift_Operators/Program16.cpp | othneildrew/CPP-Programming-Practices | 27a20c00b395446a7d2e0dd4b199f4cd9e35591b | [
"MIT"
] | null | null | null | Chapter_4_Mathematical_Logical_Bitwise_and_Shift_Operators/Program16.cpp | othneildrew/CPP-Programming-Practices | 27a20c00b395446a7d2e0dd4b199f4cd9e35591b | [
"MIT"
] | null | null | null | // Chapter 4: Program 16
/***
Write a C++ program to read two numbers. Perform AND operation and O
operations on two numbers. Perform NOT operation on first number. Declare AND,
OR, and NOT varables type of short int.
**/
# include <iostream>
# include <math.h>
# include <string>
using namespace std;
int main(void)
{
short int First_Number, Second_Number;
bool AND, OR, NOT;
cout << "\n\t Please enter first number \n";
cin >> First_Number;
cout << "\n\t Please enter second number \n";
cin >> Second_Number;
// Perform AND, OR NOT operations
(First_Number && Second_Number) ? AND = true : AND = false;
(First_Number || Second_Number) ? OR = true : OR = false;
(First_Number) ? NOT = false : NOT = true;
cout << "\t AND operation of two numbers is " << AND << endl;
cout << "\t OR operation of two numbers is " << OR << endl;
cout << "\t NOT operation of first numbers is " << NOT << endl;
system("pause");
return 0;
}
// Code written by: Othneil Drew
| 27.342105 | 78 | 0.628489 | othneildrew |
b3ab56c1bc9f402e058547736f83c4b9dbc30be9 | 654 | cpp | C++ | examples/shapes_demo_tcp/shapelib.cpp | eProsima/Integration-Services | 04e1cbbd4515f78bad5c39569f6c172b08ee78b2 | [
"Apache-2.0"
] | 2 | 2018-04-17T14:30:33.000Z | 2018-06-13T05:48:01.000Z | examples/shapes_demo_tcp/shapelib.cpp | eProsima/Integration-Services | 04e1cbbd4515f78bad5c39569f6c172b08ee78b2 | [
"Apache-2.0"
] | null | null | null | examples/shapes_demo_tcp/shapelib.cpp | eProsima/Integration-Services | 04e1cbbd4515f78bad5c39569f6c172b08ee78b2 | [
"Apache-2.0"
] | 1 | 2018-04-17T14:31:45.000Z | 2018-04-17T14:31:45.000Z | #include <iostream>
#include "ShapePubSubTypes.h"
#if defined(_WIN32) && defined (BUILD_SHARED_LIBS)
#if defined (_MSC_VER)
#pragma warning(disable: 4251)
#endif
#if defined(EPROSIMA_SHAPES_DLL_EXPORT)
#define SHAPES_LIB_EXPORT __declspec(dllexport)
#else
#define SHAPES_LIB_EXPORT __declspec(dllimport)
#endif
#else
#define SHAPES_LIB_EXPORT
#endif
using eprosima::fastrtps::TopicDataType;
TopicDataType* GetShapeType()
{
return new ShapeTypePubSubType();
}
extern "C" SHAPES_LIB_EXPORT TopicDataType* GetTopicType(const char *name)
{
if (strncmp(name, "ShapeType", 9) == 0)
{
return GetShapeType();
}
return nullptr;
} | 21.096774 | 74 | 0.746177 | eProsima |
b3ac2f9b3e5db409e3f5a69f12140ca1e3bd9c92 | 679 | hpp | C++ | code/src/utility/profiling.hpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | 3 | 2020-04-29T14:55:58.000Z | 2020-08-20T08:43:24.000Z | code/src/utility/profiling.hpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | 1 | 2022-03-12T11:37:46.000Z | 2022-03-12T20:17:38.000Z | code/src/utility/profiling.hpp | shossjer/fimbulwinter | d894e4bddb5d2e6dc31a8112d245c6a1828604e3 | [
"0BSD"
] | null | null | null | #pragma once
#if PROFILING_COZ
# include <coz.h>
#endif
namespace utility
{
namespace detail
{
#if PROFILING_COZ
struct CallWhenDestroyed
{
void (* func)();
~CallWhenDestroyed()
{
func();
}
explicit CallWhenDestroyed(void (* func)())
: func(func)
{}
};
#endif
}
}
#if PROFILING_COZ
# define profile_begin(name) do {} while(0)
# define profile_end(name) COZ_PROGRESS_NAMED(name)
# define profile_scope(name) utility::detail::CallWhenDestroyed _profile_scope_([](){ COZ_PROGRESS_NAMED(name); });
#else
# define profile_begin(name) do {} while(0)
# define profile_end(name) do {} while(0)
# define profile_scope(name) do {} while(0)
#endif
| 16.975 | 115 | 0.683358 | shossjer |
b3aca3444df7f5d0b8d4bcd29d666b52a6bc78c7 | 3,494 | cc | C++ | src/client/main.cc | sensssz/SQPKV | 828f2afec14db104f090ae2b4ed4729b97d3d9b6 | [
"Apache-2.0"
] | 1 | 2020-06-15T10:35:20.000Z | 2020-06-15T10:35:20.000Z | src/client/main.cc | sensssz/SQPKV | 828f2afec14db104f090ae2b4ed4729b97d3d9b6 | [
"Apache-2.0"
] | null | null | null | src/client/main.cc | sensssz/SQPKV | 828f2afec14db104f090ae2b4ed4729b97d3d9b6 | [
"Apache-2.0"
] | null | null | null | #include "sqpkv/connection.h"
#include "gflags/gflags.h"
#include "spdlog/spdlog.h"
#include <algorithm>
#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
DEFINE_string(server_addr, "127.0.0.1", "Address of the server");
DEFINE_int32(port, 4242, "Port number of the server");
void Show(std::string message) {
std::cout << message << std::endl;
std::cout << "> ";
}
void ShowStatus(sqpkv::Status &status) {
if (status.err()) {
Show(status.message());
} else if (status.eof()) {
std::cout << "Server is lost, exiting..." << std::endl;
exit(EXIT_FAILURE);
} else {
std::cout << "> ";
}
}
void ShowList(std::vector<std::string> list) {
size_t max_len = 0;
for (auto &item : list) {
if (item.length() > max_len) {
max_len = item.length();
}
}
max_len += 2;
std::stringstream ss;
for (size_t i = 0; i < max_len; i++) {
ss << "─";
}
auto hline = ss.str();
std::cout << "┌" << hline << "┐" << std::endl;
if (list.size() > 0) {
std::string &item = list[0];
int lpad = static_cast<int>((max_len - item.length()) / 2);
int rpad = static_cast<int>(max_len - lpad - item.length() - 1);
printf("│ %*s%*s │\n", lpad, item.c_str(), rpad, "");
}
for (size_t i = 1; i < list.size(); i++) {
auto &item = list[i];
std::cout << "├" << hline << "┤" << std::endl;
int lpad = static_cast<int>((max_len - item.length()) / 2);
int rpad = static_cast<int>(max_len - lpad - item.length() - 1);
printf("│ %*s%*s │\n", lpad, item.c_str(), rpad, "");
}
std::cout << "└" << hline << "┘" << std::endl;
std::cout << "> ";
}
// You could also take an existing vector as a parameter.
std::vector<std::string> split(std::string str, char delimiter) {
std::vector<std::string> internal;
std::stringstream ss(str); // Turn the string into a stream.
std::string tok;
while(std::getline(ss, tok, delimiter)) {
internal.push_back(tok);
}
return internal;
}
int main(int argc, char *argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
spdlog::set_pattern("[%H:%M:%S] %v");
spdlog::set_level(spdlog::level::debug);
auto console = spdlog::stdout_color_mt("console");
auto connection = sqpkv::Connection::ConnectTo(FLAGS_server_addr, FLAGS_port);
if (connection.err()) {
spdlog::get("console")->error(connection.status().ToString());
return 1;
}
Show("Welcome to SQPKV");
bool quit = false;
std::string line;
while (!quit) {
std::getline(std::cin, line);
if (line.find("get all ") == 0) {
auto parts = split(line, ' ');
std::vector<std::string> keys;
auto status = connection->GetAll(parts[2], keys);
if (status.ok()) {
ShowList(keys);
} else {
ShowStatus(status);
}
} else if (line.find("get ") == 0) {
auto parts = split(line, ' ');
std::string value;
auto status = connection->Get(parts[1], value);
if (status.ok()) {
Show(value);
} else {
ShowStatus(status);
}
} else if (line.find("put ") == 0) {
auto parts = split(line, ' ');
auto status = connection->Put(parts[1], parts[2]);
ShowStatus(status);
} else if (line.find("delete ") == 0) {
auto parts = split(line, ' ');
auto status = connection->Delete(parts[1]);
ShowStatus(status);
} else if (line.find("quit") == 0) {
quit = true;
} else {
Show("Unsupported syntax");
}
}
return 0;
}
| 27.296875 | 80 | 0.571551 | sensssz |
b3ad496d60706b021245241f40308af7a2dde686 | 773 | cpp | C++ | 2DProject2ndYear/RigidBody.cpp | ryan0432/AIE_PhysicsBS | 0ed7181b2e0624174e28dfa7b2035f8f1e597198 | [
"MIT"
] | null | null | null | 2DProject2ndYear/RigidBody.cpp | ryan0432/AIE_PhysicsBS | 0ed7181b2e0624174e28dfa7b2035f8f1e597198 | [
"MIT"
] | null | null | null | 2DProject2ndYear/RigidBody.cpp | ryan0432/AIE_PhysicsBS | 0ed7181b2e0624174e28dfa7b2035f8f1e597198 | [
"MIT"
] | null | null | null | #include "Rigidbody.h"
#include <iostream>
Rigidbody::Rigidbody(ShapeType shapeID, glm::vec2 position, glm::vec2 velocity,
float rotation, float mass) : PhysicsObject(shapeID)
{
m_position = position;
m_velocity = velocity;
m_mass = mass;
m_rotation = rotation;
}
void Rigidbody::fixedUpdate(glm::vec2 gravity, float timeStep)
{
addForce(gravity * m_mass * timeStep);
m_position += m_velocity * timeStep;
}
void Rigidbody::debug()
{
}
void Rigidbody::addForce(glm::vec2 force)
{
glm::vec2 acc;
acc = force / m_mass; //[F = m * a] Therefore [a = F / m]
m_velocity += acc;
}
void Rigidbody::addForceToActor(Rigidbody* actor, glm::vec2 force)
{
//add force to the other object
actor->addForce(force);
//add negative force to self object
addForce(-force);
}
| 20.891892 | 79 | 0.711514 | ryan0432 |
a2a60c1b142e31122b2ecb0e61ba9c49b9725fe6 | 40,139 | cpp | C++ | PC VC Examples/KMotionCNC/EditToolFile.cpp | parhansson/KMotionX | 9e827917572fee477fe7971f67709c4c2ee4f97a | [
"BSD-3-Clause"
] | 17 | 2015-01-04T19:58:54.000Z | 2020-12-15T07:01:14.000Z | PC VC Examples/KMotionCNC/EditToolFile.cpp | parhansson/KMotionX | 9e827917572fee477fe7971f67709c4c2ee4f97a | [
"BSD-3-Clause"
] | 6 | 2015-12-10T21:24:01.000Z | 2020-02-27T23:35:24.000Z | PC VC Examples/KMotionCNC/EditToolFile.cpp | parhansson/KMotionX | 9e827917572fee477fe7971f67709c4c2ee4f97a | [
"BSD-3-Clause"
] | 16 | 2015-02-07T23:42:53.000Z | 2022-01-22T06:09:43.000Z | // EditToolFile.cpp : implementation file
//
#include "stdafx.h"
#include "EditToolFile.h"
#include "OpenDlg.h"
#include "Frame.h"
#include "CPreviewFileDialog.h"
#include "DoPreview.h"
#define MAX_TOOL_LINE 200
// CEditToolFile dialog
IMPLEMENT_DYNAMIC(CEditToolFile, CDialog)
CEditToolFile::CEditToolFile(CWnd* pParent /*=NULL*/)
: CDialog(CEditToolFile::IDD, pParent)
, m_Slot0(0)
, m_Slot1(0)
, m_Slot2(0)
, m_Slot3(0)
, m_Slot4(0)
, m_Slot5(0)
, m_Slot6(0)
, m_Slot7(0)
, m_Slot8(0)
, m_Slot9(0)
, m_Slot10(0)
, m_Slot11(0)
, m_Slot12(0)
, m_Slot13(0)
, m_Slot14(0)
, m_Slot15(0)
, m_Slot16(0)
, m_Slot17(0)
, m_Slot18(0)
, m_Slot19(0)
, m_ID0(0)
, m_ID1(0)
, m_ID2(0)
, m_ID3(0)
, m_ID4(0)
, m_ID5(0)
, m_ID6(0)
, m_ID7(0)
, m_ID8(0)
, m_ID9(0)
, m_ID10(0)
, m_ID11(0)
, m_ID12(0)
, m_ID13(0)
, m_ID14(0)
, m_ID15(0)
, m_ID16(0)
, m_ID17(0)
, m_ID18(0)
, m_ID19(0)
, m_Length0(0)
, m_Length1(0)
, m_Length2(0)
, m_Length3(0)
, m_Length4(0)
, m_Length5(0)
, m_Length6(0)
, m_Length7(0)
, m_Length8(0)
, m_Length9(0)
, m_Length10(0)
, m_Length11(0)
, m_Length12(0)
, m_Length13(0)
, m_Length14(0)
, m_Length15(0)
, m_Length16(0)
, m_Length17(0)
, m_Length18(0)
, m_Length19(0)
, m_Diameter0(0)
, m_Diameter1(0)
, m_Diameter2(0)
, m_Diameter3(0)
, m_Diameter4(0)
, m_Diameter5(0)
, m_Diameter6(0)
, m_Diameter7(0)
, m_Diameter8(0)
, m_Diameter9(0)
, m_Diameter10(0)
, m_Diameter11(0)
, m_Diameter12(0)
, m_Diameter13(0)
, m_Diameter14(0)
, m_Diameter15(0)
, m_Diameter16(0)
, m_Diameter17(0)
, m_Diameter18(0)
, m_Diameter19(0)
, m_Xoffset0(0)
, m_Xoffset1(0)
, m_Xoffset2(0)
, m_Xoffset3(0)
, m_Xoffset4(0)
, m_Xoffset5(0)
, m_Xoffset6(0)
, m_Xoffset7(0)
, m_Xoffset8(0)
, m_Xoffset9(0)
, m_Xoffset10(0)
, m_Xoffset11(0)
, m_Xoffset12(0)
, m_Xoffset13(0)
, m_Xoffset14(0)
, m_Xoffset15(0)
, m_Xoffset16(0)
, m_Xoffset17(0)
, m_Xoffset18(0)
, m_Xoffset19(0)
, m_Yoffset0(0)
, m_Yoffset1(0)
, m_Yoffset2(0)
, m_Yoffset3(0)
, m_Yoffset4(0)
, m_Yoffset5(0)
, m_Yoffset6(0)
, m_Yoffset7(0)
, m_Yoffset8(0)
, m_Yoffset9(0)
, m_Yoffset10(0)
, m_Yoffset11(0)
, m_Yoffset12(0)
, m_Yoffset13(0)
, m_Yoffset14(0)
, m_Yoffset15(0)
, m_Yoffset16(0)
, m_Yoffset17(0)
, m_Yoffset18(0)
, m_Yoffset19(0)
, m_Comment0(_T(""))
, m_Comment1(_T(""))
, m_Comment2(_T(""))
, m_Comment3(_T(""))
, m_Comment4(_T(""))
, m_Comment5(_T(""))
, m_Comment6(_T(""))
, m_Comment7(_T(""))
, m_Comment8(_T(""))
, m_Comment9(_T(""))
, m_Comment10(_T(""))
, m_Comment11(_T(""))
, m_Comment12(_T(""))
, m_Comment13(_T(""))
, m_Comment14(_T(""))
, m_Comment15(_T(""))
, m_Comment16(_T(""))
, m_Comment17(_T(""))
, m_Comment18(_T(""))
, m_Comment19(_T(""))
, m_Image0(_T(""))
, m_Image1(_T(""))
, m_Image2(_T(""))
, m_Image3(_T(""))
, m_Image4(_T(""))
, m_Image5(_T(""))
, m_Image6(_T(""))
, m_Image7(_T(""))
, m_Image8(_T(""))
, m_Image9(_T(""))
, m_Image10(_T(""))
, m_Image11(_T(""))
, m_Image12(_T(""))
, m_Image13(_T(""))
, m_Image14(_T(""))
, m_Image15(_T(""))
, m_Image16(_T(""))
, m_Image17(_T(""))
, m_Image18(_T(""))
, m_Image19(_T(""))
, m_CurPage(0)
{
m_nTools=0;
m_CurPage=0;
}
CEditToolFile::~CEditToolFile()
{
}
void CEditToolFile::DoDataExchange(CDataExchange* pDX)
{
int OriginalPage=m_CurPage;
if (!pDX->m_bSaveAndValidate)
{
PutToolsToScreen(OriginalPage);
}
CDialog::DoDataExchange(pDX);
DDX_Radio(pDX, IDC_Page1, m_CurPage);
DDX_Text_Blank(pDX, IDC_Slot0, m_Slot0);
DDV_MinMaxInt_Blank(pDX, m_Slot0, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot1, m_Slot1);
DDV_MinMaxInt_Blank(pDX, m_Slot1, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot2, m_Slot2);
DDV_MinMaxInt_Blank(pDX, m_Slot2, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot3, m_Slot3);
DDV_MinMaxInt_Blank(pDX, m_Slot3, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot4, m_Slot4);
DDV_MinMaxInt_Blank(pDX, m_Slot4, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot5, m_Slot5);
DDV_MinMaxInt_Blank(pDX, m_Slot5, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot6, m_Slot6);
DDV_MinMaxInt_Blank(pDX, m_Slot6, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot7, m_Slot7);
DDV_MinMaxInt_Blank(pDX, m_Slot7, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot8, m_Slot8);
DDV_MinMaxInt_Blank(pDX, m_Slot8, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot9, m_Slot9);
DDV_MinMaxInt_Blank(pDX, m_Slot9, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot10, m_Slot10);
DDV_MinMaxInt_Blank(pDX, m_Slot10, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot11, m_Slot11);
DDV_MinMaxInt_Blank(pDX, m_Slot11, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot12, m_Slot12);
DDV_MinMaxInt_Blank(pDX, m_Slot12, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot13, m_Slot13);
DDV_MinMaxInt_Blank(pDX, m_Slot13, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot14, m_Slot14);
DDV_MinMaxInt_Blank(pDX, m_Slot14, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot15, m_Slot15);
DDV_MinMaxInt_Blank(pDX, m_Slot15, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot16, m_Slot16);
DDV_MinMaxInt_Blank(pDX, m_Slot16, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot17, m_Slot17);
DDV_MinMaxInt_Blank(pDX, m_Slot17, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot18, m_Slot18);
DDV_MinMaxInt_Blank(pDX, m_Slot18, 0, 999);
DDX_Text_Blank(pDX, IDC_Slot19, m_Slot19);
DDV_MinMaxInt_Blank(pDX, m_Slot19, 0, 999);
DDX_Text_Blank(pDX, IDC_ID0, m_ID0);
DDV_MinMaxInt_Blank(pDX, m_ID0, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID1, m_ID1);
DDV_MinMaxInt_Blank(pDX, m_ID1, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID2, m_ID2);
DDV_MinMaxInt_Blank(pDX, m_ID2, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID3, m_ID3);
DDV_MinMaxInt_Blank(pDX, m_ID3, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID4, m_ID4);
DDV_MinMaxInt_Blank(pDX, m_ID4, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID5, m_ID5);
DDV_MinMaxInt_Blank(pDX, m_ID5, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID6, m_ID6);
DDV_MinMaxInt_Blank(pDX, m_ID6, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID7, m_ID7);
DDV_MinMaxInt_Blank(pDX, m_ID7, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID8, m_ID8);
DDV_MinMaxInt_Blank(pDX, m_ID8, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID9, m_ID9);
DDV_MinMaxInt_Blank(pDX, m_ID9, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID10, m_ID10);
DDV_MinMaxInt_Blank(pDX, m_ID10, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID11, m_ID11);
DDV_MinMaxInt_Blank(pDX, m_ID11, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID12, m_ID12);
DDV_MinMaxInt_Blank(pDX, m_ID12, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID13, m_ID13);
DDV_MinMaxInt_Blank(pDX, m_ID13, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID14, m_ID14);
DDV_MinMaxInt_Blank(pDX, m_ID14, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID15, m_ID15);
DDV_MinMaxInt_Blank(pDX, m_ID15, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID16, m_ID16);
DDV_MinMaxInt_Blank(pDX, m_ID16, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID17, m_ID17);
DDV_MinMaxInt_Blank(pDX, m_ID17, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID18, m_ID18);
DDV_MinMaxInt_Blank(pDX, m_ID18, 0, 999999);
DDX_Text_Blank(pDX, IDC_ID19, m_ID19);
DDV_MinMaxInt_Blank(pDX, m_ID19, 0, 999999);
DDX_Text_Blank(pDX, IDC_Length0, m_Length0);
DDV_MinMaxDouble_Blank(pDX, m_Length0, -999,999);
DDX_Text_Blank(pDX, IDC_Length1, m_Length1);
DDV_MinMaxDouble_Blank(pDX, m_Length1, -999,999);
DDX_Text_Blank(pDX, IDC_Length2, m_Length2);
DDV_MinMaxDouble_Blank(pDX, m_Length2, -999,999);
DDX_Text_Blank(pDX, IDC_Length3, m_Length3);
DDV_MinMaxDouble_Blank(pDX, m_Length3, -999,999);
DDX_Text_Blank(pDX, IDC_Length4, m_Length4);
DDV_MinMaxDouble_Blank(pDX, m_Length4, -999,999);
DDX_Text_Blank(pDX, IDC_Length5, m_Length5);
DDV_MinMaxDouble_Blank(pDX, m_Length5, -999,999);
DDX_Text_Blank(pDX, IDC_Length6, m_Length6);
DDV_MinMaxDouble_Blank(pDX, m_Length6, -999,999);
DDX_Text_Blank(pDX, IDC_Length7, m_Length7);
DDV_MinMaxDouble_Blank(pDX, m_Length7, -999,999);
DDX_Text_Blank(pDX, IDC_Length8, m_Length8);
DDV_MinMaxDouble_Blank(pDX, m_Length8, -999,999);
DDX_Text_Blank(pDX, IDC_Length9, m_Length9);
DDV_MinMaxDouble_Blank(pDX, m_Length9, -999,999);
DDX_Text_Blank(pDX, IDC_Length10, m_Length10);
DDV_MinMaxDouble_Blank(pDX, m_Length10, -999,999);
DDX_Text_Blank(pDX, IDC_Length11, m_Length11);
DDV_MinMaxDouble_Blank(pDX, m_Length11, -999,999);
DDX_Text_Blank(pDX, IDC_Length12, m_Length12);
DDV_MinMaxDouble_Blank(pDX, m_Length12, -999,999);
DDX_Text_Blank(pDX, IDC_Length13, m_Length13);
DDV_MinMaxDouble_Blank(pDX, m_Length13, -999,999);
DDX_Text_Blank(pDX, IDC_Length14, m_Length14);
DDV_MinMaxDouble_Blank(pDX, m_Length14, -999,999);
DDX_Text_Blank(pDX, IDC_Length15, m_Length15);
DDV_MinMaxDouble_Blank(pDX, m_Length15, -999,999);
DDX_Text_Blank(pDX, IDC_Length16, m_Length16);
DDV_MinMaxDouble_Blank(pDX, m_Length16, -999,999);
DDX_Text_Blank(pDX, IDC_Length17, m_Length17);
DDV_MinMaxDouble_Blank(pDX, m_Length17, -999,999);
DDX_Text_Blank(pDX, IDC_Length18, m_Length18);
DDV_MinMaxDouble_Blank(pDX, m_Length18, -999,999);
DDX_Text_Blank(pDX, IDC_Length19, m_Length19);
DDV_MinMaxDouble_Blank(pDX, m_Length19, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset0, m_Xoffset0);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset0, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset1, m_Xoffset1);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset1, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset2, m_Xoffset2);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset2, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset3, m_Xoffset3);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset3, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset4, m_Xoffset4);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset4, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset5, m_Xoffset5);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset5, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset6, m_Xoffset6);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset6, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset7, m_Xoffset7);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset7, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset8, m_Xoffset8);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset8, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset9, m_Xoffset9);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset9, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset10, m_Xoffset10);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset10, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset11, m_Xoffset11);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset11, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset12, m_Xoffset12);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset12, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset13, m_Xoffset13);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset13, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset14, m_Xoffset14);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset14, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset15, m_Xoffset15);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset15, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset16, m_Xoffset16);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset16, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset17, m_Xoffset17);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset17, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset18, m_Xoffset18);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset18, -999,999);
DDX_Text_Blank(pDX, IDC_Xoffset19, m_Xoffset19);
DDV_MinMaxDouble_Blank(pDX, m_Xoffset19, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset0, m_Yoffset0);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset0, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset1, m_Yoffset1);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset1, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset2, m_Yoffset2);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset2, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset3, m_Yoffset3);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset3, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset4, m_Yoffset4);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset4, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset5, m_Yoffset5);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset5, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset6, m_Yoffset6);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset6, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset7, m_Yoffset7);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset7, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset8, m_Yoffset8);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset8, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset9, m_Yoffset9);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset9, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset10, m_Yoffset10);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset10, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset11, m_Yoffset11);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset11, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset12, m_Yoffset12);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset12, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset13, m_Yoffset13);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset13, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset14, m_Yoffset14);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset14, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset15, m_Yoffset15);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset15, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset16, m_Yoffset16);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset16, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset17, m_Yoffset17);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset17, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset18, m_Yoffset18);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset18, -999,999);
DDX_Text_Blank(pDX, IDC_Yoffset19, m_Yoffset19);
DDV_MinMaxDouble_Blank(pDX, m_Yoffset19, -999,999);
DDX_Text_Blank(pDX, IDC_Diameter0, m_Diameter0);
DDV_MinMaxDouble_Blank(pDX, m_Diameter0, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter1, m_Diameter1);
DDV_MinMaxDouble_Blank(pDX, m_Diameter1, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter2, m_Diameter2);
DDV_MinMaxDouble_Blank(pDX, m_Diameter2, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter3, m_Diameter3);
DDV_MinMaxDouble_Blank(pDX, m_Diameter3, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter4, m_Diameter4);
DDV_MinMaxDouble_Blank(pDX, m_Diameter4, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter5, m_Diameter5);
DDV_MinMaxDouble_Blank(pDX, m_Diameter5, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter6, m_Diameter6);
DDV_MinMaxDouble_Blank(pDX, m_Diameter6, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter7, m_Diameter7);
DDV_MinMaxDouble_Blank(pDX, m_Diameter7, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter8, m_Diameter8);
DDV_MinMaxDouble_Blank(pDX, m_Diameter8, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter9, m_Diameter9);
DDV_MinMaxDouble_Blank(pDX, m_Diameter9, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter10, m_Diameter10);
DDV_MinMaxDouble_Blank(pDX, m_Diameter10, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter11, m_Diameter11);
DDV_MinMaxDouble_Blank(pDX, m_Diameter11, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter12, m_Diameter12);
DDV_MinMaxDouble_Blank(pDX, m_Diameter12, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter13, m_Diameter13);
DDV_MinMaxDouble_Blank(pDX, m_Diameter13, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter14, m_Diameter14);
DDV_MinMaxDouble_Blank(pDX, m_Diameter14, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter15, m_Diameter15);
DDV_MinMaxDouble_Blank(pDX, m_Diameter15, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter16, m_Diameter16);
DDV_MinMaxDouble_Blank(pDX, m_Diameter16, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter17, m_Diameter17);
DDV_MinMaxDouble_Blank(pDX, m_Diameter17, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter18, m_Diameter18);
DDV_MinMaxDouble_Blank(pDX, m_Diameter18, -999, 999);
DDX_Text_Blank(pDX, IDC_Diameter19, m_Diameter19);
DDV_MinMaxDouble_Blank(pDX, m_Diameter19, -999, 999);
DDX_Text(pDX, IDC_Comment0, m_Comment0);
DDV_MaxChars(pDX, m_Comment0, 100);
DDX_Text(pDX, IDC_Comment1, m_Comment1);
DDV_MaxChars(pDX, m_Comment1, 100);
DDX_Text(pDX, IDC_Comment2, m_Comment2);
DDV_MaxChars(pDX, m_Comment2, 100);
DDX_Text(pDX, IDC_Comment3, m_Comment3);
DDV_MaxChars(pDX, m_Comment3, 100);
DDX_Text(pDX, IDC_Comment4, m_Comment4);
DDV_MaxChars(pDX, m_Comment4, 100);
DDX_Text(pDX, IDC_Comment5, m_Comment5);
DDV_MaxChars(pDX, m_Comment5, 100);
DDX_Text(pDX, IDC_Comment6, m_Comment6);
DDV_MaxChars(pDX, m_Comment6, 100);
DDX_Text(pDX, IDC_Comment7, m_Comment7);
DDV_MaxChars(pDX, m_Comment7, 100);
DDX_Text(pDX, IDC_Comment8, m_Comment8);
DDV_MaxChars(pDX, m_Comment8, 100);
DDX_Text(pDX, IDC_Comment9, m_Comment9);
DDV_MaxChars(pDX, m_Comment9, 100);
DDX_Text(pDX, IDC_Comment10, m_Comment10);
DDV_MaxChars(pDX, m_Comment10, 100);
DDX_Text(pDX, IDC_Comment11, m_Comment11);
DDV_MaxChars(pDX, m_Comment11, 100);
DDX_Text(pDX, IDC_Comment12, m_Comment12);
DDV_MaxChars(pDX, m_Comment12, 100);
DDX_Text(pDX, IDC_Comment13, m_Comment13);
DDV_MaxChars(pDX, m_Comment13, 100);
DDX_Text(pDX, IDC_Comment14, m_Comment14);
DDV_MaxChars(pDX, m_Comment14, 100);
DDX_Text(pDX, IDC_Comment15, m_Comment15);
DDV_MaxChars(pDX, m_Comment15, 100);
DDX_Text(pDX, IDC_Comment16, m_Comment16);
DDV_MaxChars(pDX, m_Comment16, 100);
DDX_Text(pDX, IDC_Comment17, m_Comment17);
DDV_MaxChars(pDX, m_Comment17, 100);
DDX_Text(pDX, IDC_Comment18, m_Comment18);
DDV_MaxChars(pDX, m_Comment18, 100);
DDX_Text(pDX, IDC_Comment19, m_Comment19);
DDV_MaxChars(pDX, m_Comment19, 100);
DDX_Text(pDX, IDC_Image0, m_Image0);
DDV_MaxChars(pDX, m_Image0, 100);
DDX_Text(pDX, IDC_Image1, m_Image1);
DDV_MaxChars(pDX, m_Image1, 100);
DDX_Text(pDX, IDC_Image2, m_Image2);
DDV_MaxChars(pDX, m_Image2, 100);
DDX_Text(pDX, IDC_Image3, m_Image3);
DDV_MaxChars(pDX, m_Image3, 100);
DDX_Text(pDX, IDC_Image4, m_Image4);
DDV_MaxChars(pDX, m_Image4, 100);
DDX_Text(pDX, IDC_Image5, m_Image5);
DDV_MaxChars(pDX, m_Image5, 100);
DDX_Text(pDX, IDC_Image6, m_Image6);
DDV_MaxChars(pDX, m_Image6, 100);
DDX_Text(pDX, IDC_Image7, m_Image7);
DDV_MaxChars(pDX, m_Image7, 100);
DDX_Text(pDX, IDC_Image8, m_Image8);
DDV_MaxChars(pDX, m_Image8, 100);
DDX_Text(pDX, IDC_Image9, m_Image9);
DDV_MaxChars(pDX, m_Image9, 100);
DDX_Text(pDX, IDC_Image10, m_Image10);
DDV_MaxChars(pDX, m_Image10, 100);
DDX_Text(pDX, IDC_Image11, m_Image11);
DDV_MaxChars(pDX, m_Image11, 100);
DDX_Text(pDX, IDC_Image12, m_Image12);
DDV_MaxChars(pDX, m_Image12, 100);
DDX_Text(pDX, IDC_Image13, m_Image13);
DDV_MaxChars(pDX, m_Image13, 100);
DDX_Text(pDX, IDC_Image14, m_Image14);
DDV_MaxChars(pDX, m_Image14, 100);
DDX_Text(pDX, IDC_Image15, m_Image15);
DDV_MaxChars(pDX, m_Image15, 100);
DDX_Text(pDX, IDC_Image16, m_Image16);
DDV_MaxChars(pDX, m_Image16, 100);
DDX_Text(pDX, IDC_Image17, m_Image17);
DDV_MaxChars(pDX, m_Image17, 100);
DDX_Text(pDX, IDC_Image18, m_Image18);
DDV_MaxChars(pDX, m_Image18, 100);
DDX_Text(pDX, IDC_Image19, m_Image19);
DDV_MaxChars(pDX, m_Image19, 100);
if (pDX->m_bSaveAndValidate)
{
GetToolsFromScreen(OriginalPage);
}
}
BEGIN_MESSAGE_MAP(CEditToolFile, CDialog)
ON_BN_CLICKED(IDC_Page1, &CEditToolFile::OnBnClickedPage1)
ON_BN_CLICKED(IDC_Page2, &CEditToolFile::OnBnClickedPage2)
ON_BN_CLICKED(IDC_Page3, &CEditToolFile::OnBnClickedPage3)
ON_BN_CLICKED(IDC_Page4, &CEditToolFile::OnBnClickedPage4)
ON_BN_CLICKED(IDC_Page5, &CEditToolFile::OnBnClickedPage5)
ON_BN_CLICKED(IDC_SORT, &CEditToolFile::OnBnClickedSort)
ON_BN_CLICKED(IDC_ImageDir0, &CEditToolFile::OnBnClickedImagedir0)
ON_BN_CLICKED(IDC_ImageDir1, &CEditToolFile::OnBnClickedImagedir1)
ON_BN_CLICKED(IDC_ImageDir2, &CEditToolFile::OnBnClickedImagedir2)
ON_BN_CLICKED(IDC_ImageDir3, &CEditToolFile::OnBnClickedImagedir3)
ON_BN_CLICKED(IDC_ImageDir4, &CEditToolFile::OnBnClickedImagedir4)
ON_BN_CLICKED(IDC_ImageDir5, &CEditToolFile::OnBnClickedImagedir5)
ON_BN_CLICKED(IDC_ImageDir6, &CEditToolFile::OnBnClickedImagedir6)
ON_BN_CLICKED(IDC_ImageDir7, &CEditToolFile::OnBnClickedImagedir7)
ON_BN_CLICKED(IDC_ImageDir8, &CEditToolFile::OnBnClickedImagedir8)
ON_BN_CLICKED(IDC_ImageDir9, &CEditToolFile::OnBnClickedImagedir9)
ON_BN_CLICKED(IDC_ImageDir10, &CEditToolFile::OnBnClickedImagedir10)
ON_BN_CLICKED(IDC_ImageDir11, &CEditToolFile::OnBnClickedImagedir11)
ON_BN_CLICKED(IDC_ImageDir12, &CEditToolFile::OnBnClickedImagedir12)
ON_BN_CLICKED(IDC_ImageDir13, &CEditToolFile::OnBnClickedImagedir13)
ON_BN_CLICKED(IDC_ImageDir14, &CEditToolFile::OnBnClickedImagedir14)
ON_BN_CLICKED(IDC_ImageDir15, &CEditToolFile::OnBnClickedImagedir15)
ON_BN_CLICKED(IDC_ImageDir16, &CEditToolFile::OnBnClickedImagedir16)
ON_BN_CLICKED(IDC_ImageDir17, &CEditToolFile::OnBnClickedImagedir17)
ON_BN_CLICKED(IDC_ImageDir18, &CEditToolFile::OnBnClickedImagedir18)
ON_BN_CLICKED(IDC_ImageDir19, &CEditToolFile::OnBnClickedImagedir19)
END_MESSAGE_MAP()
void CEditToolFile::DDX_Text_Blank(CDataExchange* pDX, int nIDC, int& value)
{
char Buf[MAX_TOOL_LINE+1];
m_prevID=nIDC;
GetDlgItemText(nIDC,Buf,MAX_TOOL_LINE);
if (Buf[0]==0)SetDlgItemText(nIDC,"0");
DDX_Text(pDX, nIDC, value);
}
void CEditToolFile::DDX_Text_Blank(CDataExchange* pDX, int nIDC, double& value)
{
char Buf[MAX_TOOL_LINE+1];
m_prevID=nIDC;
GetDlgItemText(nIDC,Buf,MAX_TOOL_LINE);
if (Buf[0]==0)SetDlgItemText(nIDC,"0");
DDX_Text(pDX, nIDC, value);
}
void CEditToolFile::DDV_MinMaxInt_Blank(CDataExchange* pDX, int value, int minVal, int maxVal)
{
char Buf[MAX_TOOL_LINE+1];
DDV_MinMaxInt(pDX, value, minVal, maxVal);
GetDlgItemText(m_prevID,Buf,MAX_TOOL_LINE);
if (Buf[0]=='0' && Buf[1]==0) SetDlgItemText(m_prevID,"");
}
void CEditToolFile::DDV_MinMaxDouble_Blank(CDataExchange* pDX, double const& value, double minVal, double maxVal)
{
char Buf[MAX_TOOL_LINE+1];
DDV_MinMaxDouble(pDX, value, minVal, maxVal);
GetDlgItemText(m_prevID,Buf,MAX_TOOL_LINE);
if (Buf[0]=='0' && Buf[1]==0) SetDlgItemText(m_prevID,"");
}
// CEditToolFile message handlers
int CEditToolFile::LoadFile(CString File)
{
int result,i,Revision=0;
CString Comment,Image,s;
int ID,Slot;
double Diameter,Length,Xoffset,Yoffset;
CStdioFile f;
// check if there is no path specified, then add in default
if (File.Find(':') == -1 && File.Find("\\\\") == -1)
{
File = TheFrame->MainPathRoot + DATA_SUB_DIR + File;
}
if(!f.Open(File, CFile::modeRead|CFile::typeText))
{
AfxMessageBox("Unable to open Tool Table file:\r\r" + File);
return 1;
}
if(!f.ReadString(s))
{
AfxMessageBox("Invalid Tool Table file (line 1):\r\r" + File);
f.Close();
return 1;
}
s.MakeUpper();
if (s.Find("COMMENT")==-1 || s.Find("DIAM")==-1 || s.Find("LEN")==-1)
{
AfxMessageBox("Invalid Tool Table file (line 1):\r\r" + File);
f.Close();
return 1;
}
if (s.Find("XOFFSET")>0 && s.Find("YOFFSET")>0 && s.Find("IMAGE")>0) Revision = 1;
int n,Tool=0,line=1;
while (f.ReadString(s))
{
// remove whitespace
s.Trim();
line++;
if (!s.IsEmpty())
{
if (Tool >= MAX_TOOLS)
{
AfxMessageBox("Invalid Tool Table file:\r\r" + File + "\r\rToo many Tools Max Allowed is 99");
f.Close();
return 1;
}
if (Revision==0)
{
result = sscanf(s,"%d%d%lf%lf%n",&Slot,&ID,&Length,&Diameter,&n);
Xoffset=Yoffset=0;
if (result !=4)
{
CString err;
err.Format("Line %d doesn't have 4 valid numbers",line);
AfxMessageBox("Invalid Tool Table file:\r\r" + File + "\r\r" + err);
f.Close();
return 1;
}
}
else
{
result = sscanf(s,"%d%d%lf%lf%lf%lf%n",&Slot,&ID,&Length,&Diameter,&Xoffset,&Yoffset,&n);
if (result !=6)
{
CString err;
err.Format("Line %d doesn't have 6 valid numbers",line);
AfxMessageBox("Invalid Tool Table file:\r\r" + File + "\r\r" + err);
f.Close();
return 1;
}
}
s.Delete(0,n);
Comment = s;
//remove beginning and ending whitespace
Comment.Trim();
if (Revision==0)
{
Image = "";
PutTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
Tool++;
}
else
{
BOOL bImageSuccess = TRUE;
BOOL bCommentSuccess = TRUE;
//first isolate our image name
if(Comment.Right(1) == '"')
{
Comment.Delete(Comment.GetLength()-1,1);
i=Comment.ReverseFind('"');
if (i!=-1)
{
Image = Comment.Mid(i+1);
Comment = Comment.Left(i-1);
Comment.Trim();
}
else
{
bImageSuccess = FALSE;
}
}
if(bImageSuccess)
{
//Isolate our comment
if(Comment.GetAt(0) == '"' && Comment.Right(1) == '"')
{
Comment.Delete(0,1);
Comment.Delete(Comment.GetLength()-1,1);
}
else
{
bCommentSuccess = FALSE;
}
}
if(!bImageSuccess)
{
CString err;
err.Format("Line %d doesn't have matching quotation marks for Image",line);
AfxMessageBox("Invalid Tool Table file:\r\r" + File + "\r\r" + err);
f.Close();
return 1;
}
if (!bCommentSuccess)
{
CString err;
err.Format("Line %d doesn't have quotation marks for comment",line);
AfxMessageBox("Invalid Tool Table file:\r\r" + File + "\r\r" + err);
f.Close();
return 1;
}
PutTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
Tool++;
}
}
}
f.Close();
// Blank out others
for (int i=Tool; i<MAX_TOOLS; i++)
{
PutTool(i,0,0,0,0,0,0,"","");
}
m_nTools=Tool; // remember how many tools defined
return 0;
}
void CEditToolFile::PutToolsToScreen(int page)
{
CString Comment,Image;
int ID,Slot;
double Diameter,Length,Xoffset,Yoffset;
for (int i=0; i<20; i++)
{
GetTool(i+page*20,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutToolID(i,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
}
}
void CEditToolFile::GetToolsFromScreen(int page)
{
CString Comment,Image;
int ID,Slot;
double Diameter,Length,Xoffset,Yoffset;
for (int i=0; i<20; i++)
{
GetToolID(i,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutTool(i+page*20,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
}
}
void CEditToolFile::PutTool(int Tool, int Slot, int ID, double Length, double Diameter, double Xoffset, double Yoffset, CString Comment, CString Image)
{
if (Tool>=0 && Tool<MAX_TOOLS)
{
m_Slot[Tool]=Slot; m_ID[Tool]=ID; m_Length[Tool]=Length; m_Diameter[Tool]=Diameter; m_Xoffset[Tool]=Xoffset; m_Yoffset[Tool]=Yoffset; m_Comment[Tool]=Comment; m_Image[Tool]=Image;
}
}
void CEditToolFile::GetTool(int Tool, int &Slot, int &ID, double &Length, double &Diameter, double &Xoffset, double &Yoffset, CString &Comment, CString &Image)
{
if (Tool>=0 && Tool<MAX_TOOLS)
{
Slot=m_Slot[Tool]; ID=m_ID[Tool]; Length=m_Length[Tool]; Diameter=m_Diameter[Tool]; Xoffset=m_Xoffset[Tool]; Yoffset=m_Yoffset[Tool]; Comment=m_Comment[Tool]; Image=m_Image[Tool];
}
else
{
Slot=0; ID=0; Length=0; Diameter=0; Xoffset=0; Yoffset=0; Comment=""; Image="";
}
}
void CEditToolFile::PutToolID(int Tool, int Slot, int ID, double Length, double Diameter, double Xoffset, double Yoffset, CString Comment, CString Image)
{
switch (Tool)
{
case 0: m_Slot0=Slot; m_ID0=ID; m_Length0=Length; m_Diameter0=Diameter; m_Xoffset0=Xoffset;m_Yoffset0=Yoffset;m_Comment0=Comment;m_Image0=Image; break;
case 1: m_Slot1=Slot; m_ID1=ID; m_Length1=Length; m_Diameter1=Diameter; m_Xoffset1=Xoffset;m_Yoffset1=Yoffset;m_Comment1=Comment;m_Image1=Image; break;
case 2: m_Slot2=Slot; m_ID2=ID; m_Length2=Length; m_Diameter2=Diameter; m_Xoffset2=Xoffset;m_Yoffset2=Yoffset;m_Comment2=Comment;m_Image2=Image; break;
case 3: m_Slot3=Slot; m_ID3=ID; m_Length3=Length; m_Diameter3=Diameter; m_Xoffset3=Xoffset;m_Yoffset3=Yoffset;m_Comment3=Comment;m_Image3=Image; break;
case 4: m_Slot4=Slot; m_ID4=ID; m_Length4=Length; m_Diameter4=Diameter; m_Xoffset4=Xoffset;m_Yoffset4=Yoffset;m_Comment4=Comment;m_Image4=Image; break;
case 5: m_Slot5=Slot; m_ID5=ID; m_Length5=Length; m_Diameter5=Diameter; m_Xoffset5=Xoffset;m_Yoffset5=Yoffset;m_Comment5=Comment;m_Image5=Image; break;
case 6: m_Slot6=Slot; m_ID6=ID; m_Length6=Length; m_Diameter6=Diameter; m_Xoffset6=Xoffset;m_Yoffset6=Yoffset;m_Comment6=Comment;m_Image6=Image; break;
case 7: m_Slot7=Slot; m_ID7=ID; m_Length7=Length; m_Diameter7=Diameter; m_Xoffset7=Xoffset;m_Yoffset7=Yoffset;m_Comment7=Comment;m_Image7=Image; break;
case 8: m_Slot8=Slot; m_ID8=ID; m_Length8=Length; m_Diameter8=Diameter; m_Xoffset8=Xoffset;m_Yoffset8=Yoffset;m_Comment8=Comment;m_Image8=Image; break;
case 9: m_Slot9=Slot; m_ID9=ID; m_Length9=Length; m_Diameter9=Diameter; m_Xoffset9=Xoffset;m_Yoffset9=Yoffset;m_Comment9=Comment;m_Image9=Image; break;
case 10: m_Slot10=Slot; m_ID10=ID; m_Length10=Length; m_Diameter10=Diameter; m_Xoffset10=Xoffset;m_Yoffset10=Yoffset;m_Comment10=Comment;m_Image10=Image; break;
case 11: m_Slot11=Slot; m_ID11=ID; m_Length11=Length; m_Diameter11=Diameter; m_Xoffset11=Xoffset;m_Yoffset11=Yoffset;m_Comment11=Comment;m_Image11=Image; break;
case 12: m_Slot12=Slot; m_ID12=ID; m_Length12=Length; m_Diameter12=Diameter; m_Xoffset12=Xoffset;m_Yoffset12=Yoffset;m_Comment12=Comment;m_Image12=Image; break;
case 13: m_Slot13=Slot; m_ID13=ID; m_Length13=Length; m_Diameter13=Diameter; m_Xoffset13=Xoffset;m_Yoffset13=Yoffset;m_Comment13=Comment;m_Image13=Image; break;
case 14: m_Slot14=Slot; m_ID14=ID; m_Length14=Length; m_Diameter14=Diameter; m_Xoffset14=Xoffset;m_Yoffset14=Yoffset;m_Comment14=Comment;m_Image14=Image; break;
case 15: m_Slot15=Slot; m_ID15=ID; m_Length15=Length; m_Diameter15=Diameter; m_Xoffset15=Xoffset;m_Yoffset15=Yoffset;m_Comment15=Comment;m_Image15=Image; break;
case 16: m_Slot16=Slot; m_ID16=ID; m_Length16=Length; m_Diameter16=Diameter; m_Xoffset16=Xoffset;m_Yoffset16=Yoffset;m_Comment16=Comment;m_Image16=Image; break;
case 17: m_Slot17=Slot; m_ID17=ID; m_Length17=Length; m_Diameter17=Diameter; m_Xoffset17=Xoffset;m_Yoffset17=Yoffset;m_Comment17=Comment;m_Image17=Image; break;
case 18: m_Slot18=Slot; m_ID18=ID; m_Length18=Length; m_Diameter18=Diameter; m_Xoffset18=Xoffset;m_Yoffset18=Yoffset;m_Comment18=Comment;m_Image18=Image; break;
case 19: m_Slot19=Slot; m_ID19=ID; m_Length19=Length; m_Diameter19=Diameter; m_Xoffset19=Xoffset;m_Yoffset19=Yoffset;m_Comment19=Comment;m_Image19=Image; break;
}
}
void CEditToolFile::GetToolID(int Tool, int &Slot, int &ID, double &Length, double &Diameter, double &Xoffset, double &Yoffset, CString &Comment, CString &Image)
{
switch (Tool)
{
case 0: Slot=m_Slot0; ID=m_ID0; Length=m_Length0; Diameter=m_Diameter0; Xoffset=m_Xoffset0; Yoffset=m_Yoffset0; Comment=m_Comment0; Image=m_Image0; break;
case 1: Slot=m_Slot1; ID=m_ID1; Length=m_Length1; Diameter=m_Diameter1; Xoffset=m_Xoffset1; Yoffset=m_Yoffset1; Comment=m_Comment1; Image=m_Image1; break;
case 2: Slot=m_Slot2; ID=m_ID2; Length=m_Length2; Diameter=m_Diameter2; Xoffset=m_Xoffset2; Yoffset=m_Yoffset2; Comment=m_Comment2; Image=m_Image2; break;
case 3: Slot=m_Slot3; ID=m_ID3; Length=m_Length3; Diameter=m_Diameter3; Xoffset=m_Xoffset3; Yoffset=m_Yoffset3; Comment=m_Comment3; Image=m_Image3; break;
case 4: Slot=m_Slot4; ID=m_ID4; Length=m_Length4; Diameter=m_Diameter4; Xoffset=m_Xoffset4; Yoffset=m_Yoffset4; Comment=m_Comment4; Image=m_Image4; break;
case 5: Slot=m_Slot5; ID=m_ID5; Length=m_Length5; Diameter=m_Diameter5; Xoffset=m_Xoffset5; Yoffset=m_Yoffset5; Comment=m_Comment5; Image=m_Image5; break;
case 6: Slot=m_Slot6; ID=m_ID6; Length=m_Length6; Diameter=m_Diameter6; Xoffset=m_Xoffset6; Yoffset=m_Yoffset6; Comment=m_Comment6; Image=m_Image6; break;
case 7: Slot=m_Slot7; ID=m_ID7; Length=m_Length7; Diameter=m_Diameter7; Xoffset=m_Xoffset7; Yoffset=m_Yoffset7; Comment=m_Comment7; Image=m_Image7; break;
case 8: Slot=m_Slot8; ID=m_ID8; Length=m_Length8; Diameter=m_Diameter8; Xoffset=m_Xoffset8; Yoffset=m_Yoffset8; Comment=m_Comment8; Image=m_Image8; break;
case 9: Slot=m_Slot9; ID=m_ID9; Length=m_Length9; Diameter=m_Diameter9; Xoffset=m_Xoffset9; Yoffset=m_Yoffset9; Comment=m_Comment9; Image=m_Image9; break;
case 10: Slot=m_Slot10; ID=m_ID10; Length=m_Length10; Diameter=m_Diameter10; Xoffset=m_Xoffset10; Yoffset=m_Yoffset10; Comment=m_Comment10; Image=m_Image10; break;
case 11: Slot=m_Slot11; ID=m_ID11; Length=m_Length11; Diameter=m_Diameter11; Xoffset=m_Xoffset11; Yoffset=m_Yoffset11; Comment=m_Comment11; Image=m_Image11; break;
case 12: Slot=m_Slot12; ID=m_ID12; Length=m_Length12; Diameter=m_Diameter12; Xoffset=m_Xoffset12; Yoffset=m_Yoffset12; Comment=m_Comment12; Image=m_Image12; break;
case 13: Slot=m_Slot13; ID=m_ID13; Length=m_Length13; Diameter=m_Diameter13; Xoffset=m_Xoffset13; Yoffset=m_Yoffset13; Comment=m_Comment13; Image=m_Image13; break;
case 14: Slot=m_Slot14; ID=m_ID14; Length=m_Length14; Diameter=m_Diameter14; Xoffset=m_Xoffset14; Yoffset=m_Yoffset14; Comment=m_Comment14; Image=m_Image14; break;
case 15: Slot=m_Slot15; ID=m_ID15; Length=m_Length15; Diameter=m_Diameter15; Xoffset=m_Xoffset15; Yoffset=m_Yoffset15; Comment=m_Comment15; Image=m_Image15; break;
case 16: Slot=m_Slot16; ID=m_ID16; Length=m_Length16; Diameter=m_Diameter16; Xoffset=m_Xoffset16; Yoffset=m_Yoffset16; Comment=m_Comment16; Image=m_Image16; break;
case 17: Slot=m_Slot17; ID=m_ID17; Length=m_Length17; Diameter=m_Diameter17; Xoffset=m_Xoffset17; Yoffset=m_Yoffset17; Comment=m_Comment17; Image=m_Image17; break;
case 18: Slot=m_Slot18; ID=m_ID18; Length=m_Length18; Diameter=m_Diameter18; Xoffset=m_Xoffset18; Yoffset=m_Yoffset18; Comment=m_Comment18; Image=m_Image18; break;
case 19: Slot=m_Slot19; ID=m_ID19; Length=m_Length19; Diameter=m_Diameter19; Xoffset=m_Xoffset19; Yoffset=m_Yoffset19; Comment=m_Comment19; Image=m_Image19; break;
}
}
void CEditToolFile::SortToolTable()
{
CString Comment,Comment2,Image,Image2;
int ID,ID2,Slot,Slot2;
double Diameter,Diameter2,Length,Length2,Xoffset,Xoffset2,Yoffset,Yoffset2;
bool something_swapped;
// bubble sort the tool table using Slot number as key
do
{
something_swapped=false;
for (int i=0; i<MAX_TOOLS-1; i++)
{
GetTool(i,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
GetTool(i+1,Slot2,ID2,Length2,Diameter2,Xoffset2,Yoffset2,Comment2,Image2);
// sort first by Slot number then by ID also blanks to end
if ((ID==0 && ID2!=0) ||
(ID==0 && Slot==0 && (ID2!=0 || Slot2!=0)) ||
(ID2!=0 && ID !=0 && ID2 < ID) ||
(ID2==ID && Slot2!=0 && Slot!=0 && Slot2<Slot))
{
//swap
PutTool(i,Slot2,ID2,Length2,Diameter2,Xoffset2,Yoffset2,Comment2,Image2);
PutTool(i+1,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
something_swapped=true;
}
}
}
while (something_swapped);
for (m_nTools=0; m_nTools<MAX_TOOLS; m_nTools++)
{
GetTool(m_nTools,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
if (!Slot && !ID) break;
}
}
int CEditToolFile::SaveFile(CString File)
{
FILE *f = fopen(File,"wt");
SortToolTable();
if (!f)
{
AfxMessageBox("Unable to write Tool Table file:\r\r" + File);
return 1;
}
fprintf(f,"SLOT ID LENGTH DIAMETER XOFFSET YOFFSET COMMENT IMAGE\n");
fprintf(f,"\n");
CString Comment,Image;
int ID, Slot;
double Diameter,Length,Xoffset,Yoffset;
for (int i=0; i<MAX_TOOLS; i++)
{
GetTool(i,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
if (Slot || ID) fprintf(f,"%3d %6d %15.6f %15.6f %15.6f %15.6f \"%s\" \"%s\"\n",Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment.GetBuffer(),Image.GetBuffer());
}
fclose(f);
return 0;
}
void CEditToolFile::ChangeLength(int Tool, double NewLength)
{
CString Comment,Image;
int ID, Slot;
double Diameter,Length,Xoffset,Yoffset;
GetTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutTool(Tool,Slot,ID,NewLength,Diameter,Xoffset,Yoffset,Comment,Image);
}
void CEditToolFile::ChangeDiameter(int Tool, double NewDiameter)
{
CString Comment,Image;
int ID, Slot;
double Diameter,Length,Xoffset,Yoffset;
GetTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutTool(Tool,Slot,ID,Length,NewDiameter,Xoffset,Yoffset,Comment,Image);
}
void CEditToolFile::ChangeOffsetX(int Tool, double NewXoffset)
{
CString Comment,Image;
int ID, Slot;
double Diameter,Length,Xoffset,Yoffset;
GetTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutTool(Tool,Slot,ID,Length,Diameter,NewXoffset,Yoffset,Comment,Image);
}
void CEditToolFile::ChangeOffsetY(int Tool, double NewYoffset)
{
CString Comment,Image;
int ID, Slot;
double Diameter,Length,Xoffset,Yoffset;
GetTool(Tool,Slot,ID,Length,Diameter,Xoffset,Yoffset,Comment,Image);
PutTool(Tool,Slot,ID,Length,Diameter,Xoffset,NewYoffset,Comment,Image);
}
void CEditToolFile::OnBnClickedPage1()
{
if (!UpdateData(TRUE)) return;
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedPage2()
{
if (!UpdateData(TRUE)) return;
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedPage3()
{
if (!UpdateData(TRUE)) return;
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedPage4()
{
if (!UpdateData(TRUE)) return;
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedPage5()
{
if (!UpdateData(TRUE)) return;
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedSort()
{
if (!UpdateData(TRUE)) return;
SortToolTable();
UpdateData(FALSE);
}
void CEditToolFile::OnBnClickedImagedir0()
{
DoImageDir(m_Image[0+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir1()
{
DoImageDir(m_Image[1+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir2()
{
DoImageDir(m_Image[2+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir3()
{
DoImageDir(m_Image[3+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir4()
{
DoImageDir(m_Image[4+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir5()
{
DoImageDir(m_Image[5+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir6()
{
DoImageDir(m_Image[6+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir7()
{
DoImageDir(m_Image[7+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir8()
{
DoImageDir(m_Image[8+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir9()
{
DoImageDir(m_Image[9+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir10()
{
DoImageDir(m_Image[10+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir11()
{
DoImageDir(m_Image[11+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir12()
{
DoImageDir(m_Image[12+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir13()
{
DoImageDir(m_Image[13+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir14()
{
DoImageDir(m_Image[14+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir15()
{
DoImageDir(m_Image[15+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir16()
{
DoImageDir(m_Image[16+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir17()
{
DoImageDir(m_Image[17+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir18()
{
DoImageDir(m_Image[18+m_CurPage*20]);
}
void CEditToolFile::OnBnClickedImagedir19()
{
DoImageDir(m_Image[19+m_CurPage*20]);
}
void CEditToolFile::DoImageDir(CString &Image)
{
CString s, FullPath,ImagePath=TheFrame->MainPathRoot + TOOL_IMAGE_SUB_DIR;
if (!UpdateData(TRUE)) return;
CDoPreview preview;
if (Image=="")
FullPath="";
else
{
if (Image.Find(':') == -1 && Image.Find("\\\\") == -1)
FullPath=ImagePath+Image;
else
FullPath=Image;
}
CPreviewFileDialog FileDlg(&preview,TRUE,".wrl",FullPath,OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST,
"VRML Image Files (*.wrl)|*.wrl|All Files (*.*)|*.*||");
FileDlg.m_ofn.lpstrInitialDir = ImagePath;
if(FileDlg.DoModal() == IDOK)
{
Image = FileDlg.GetPathName();
if (Image.Find(ImagePath) == 0)
{
Image.Delete(0, ImagePath.GetLength());
}
}
UpdateData(FALSE);
}
| 34.543029 | 183 | 0.724607 | parhansson |
a2a8849c07fcadb5b1dda577dfc2643c3fec2f07 | 4,398 | cpp | C++ | src/Leviathan_Editor/Leviathan_Editor.cpp | wakare/Leviathan | 8a488f014d6235c5c6e6422c9f53c82635b7ebf7 | [
"MIT"
] | 3 | 2019-03-05T13:05:30.000Z | 2019-12-16T05:56:21.000Z | src/Leviathan_Editor/Leviathan_Editor.cpp | wakare/Leviathan | 8a488f014d6235c5c6e6422c9f53c82635b7ebf7 | [
"MIT"
] | null | null | null | src/Leviathan_Editor/Leviathan_Editor.cpp | wakare/Leviathan | 8a488f014d6235c5c6e6422c9f53c82635b7ebf7 | [
"MIT"
] | null | null | null | #include "Leviathan_Editor.h"
#include <thread>
#include <QLabel>
#include <QLayout>
#include <QLineEdit>
#include <QSplitter>
#include <QSizePolicy>
#include "LevScene.h"
#include "LevAttributeWidget.h"
Leviathan_Editor::Leviathan_Editor(QWidget *parent)
: QMainWindow(parent)
{
ui.setupUi(this);
bool seted = _setupWidget();
LEV_ASSERT(seted);
m_timer.reset(new QTimer);
m_timer->setInterval(100);
connect(m_openGL_widget.data(), SIGNAL(resized()), this, SLOT(SLOT_RESIZE()));
connect(m_timer.data(), SIGNAL(timeout()), this, SLOT(SLOT_UPDATE()));
m_timer->start();
}
void Leviathan_Editor::SLOT_RESIZE()
{
if (!m_leviathan_proxy || !m_leviathan_proxy->HasInited())
{
return;
}
unsigned handle = m_leviathan_proxy->GetWindowHandle();
unsigned width = m_openGL_widget->width();
unsigned height = m_openGL_widget->height();
MoveWindow((HWND)handle, 0, 0, width, height, true);
}
void Leviathan_Editor::resizeEvent(QResizeEvent *event)
{
static bool _first = true;
if (_first)
{
_widget_initialized();
_first = false;
}
}
void Leviathan_Editor::closeEvent(QCloseEvent * event)
{
m_leviathan_proxy->Stop();
while (!m_leviathan_proxy->HasStoped())
{
Sleep(100);
}
QMainWindow::closeEvent(event);
}
void Leviathan_Editor::SLOT_UPDATE()
{
static bool _proxy_inited = false;
if (!_proxy_inited && m_leviathan_proxy && m_leviathan_proxy->HasInited())
{
_leviathan_initialized();
_proxy_inited = true;
return;
}
if (_proxy_inited)
{
m_runtime_object_view->Update();
}
}
void Leviathan_Editor::_widget_initialized()
{
_attachRenderer();
}
void Leviathan_Editor::_leviathan_initialized()
{
SLOT_RESIZE();
auto _scene_modified_callback = [this]()
{
_update_runtime_scene_object();
};
m_leviathan_proxy->UpdateSceneData([this, _scene_modified_callback](Scene::LevScene& scene)
{
scene.RegisterModifiedCallback(_scene_modified_callback);
});
_update_runtime_scene_object();
}
void Leviathan_Editor::_update_runtime_scene_object()
{
m_leviathan_proxy->UpdateSceneData([this](Scene::LevScene& scene)
{
m_runtime_object_view->SetSceneData(scene.GetSceneData());
});
}
void Leviathan_Editor::_attachRenderer()
{
unsigned width = m_openGL_widget->width();
unsigned height = m_openGL_widget->height();
unsigned handle = m_openGL_widget->winId();
std::thread _lev_render_thread([this, width, height, handle]()
{
m_leviathan_proxy.Reset(new LeviathanProxy);
m_leviathan_proxy->Init(width, height, handle);
while (!m_leviathan_proxy->HasStoped())
{
m_leviathan_proxy->Update();
}
LogLine("[DEBUG] Exit leviathan proxy.");
});
_lev_render_thread.detach();
}
bool Leviathan_Editor::_setupWidget()
{
EXIT_IF_FALSE(_setupResourceListView());
EXIT_IF_FALSE(_setupSceneRuntimeObjectView());
EXIT_IF_FALSE(_setupAttributePanelView());
m_openGL_widget.reset(new QOpenGLWidget);
m_main_splitter.reset(new QSplitter(Qt::Horizontal, ui.centralWidget));
m_middle_splitter.reset(new QSplitter(Qt::Vertical));
m_middle_splitter->addWidget(m_openGL_widget.data());
m_middle_splitter->addWidget(m_resource_view.data());
m_middle_splitter->setStretchFactor(0, 5);
m_middle_splitter->setStretchFactor(1, 1);
m_main_splitter->addWidget(m_runtime_object_view.data());
m_main_splitter->addWidget(m_middle_splitter.data());
m_main_splitter->addWidget(m_attribute_view.data());
m_main_splitter->setStretchFactor(0, 1);
m_main_splitter->setStretchFactor(1, 5);
m_main_splitter->setStretchFactor(2, 1);
ui.centralWidget->setLayout(new QGridLayout);
ui.centralWidget->layout()->addWidget(m_main_splitter.data());
return true;
}
bool Leviathan_Editor::_setupResourceListView()
{
m_resource_view.reset(new LevResourcesListView);
// For test
auto command_args = QApplication::arguments();
if (command_args.size() > 1)
{
auto& resource_folder_path = command_args[1];
// TODO: the way getting raw char pointer too stupid
EXIT_IF_FALSE(m_resource_view->SetResourcesFolderPath(resource_folder_path.toStdString().c_str()));
EXIT_IF_FALSE(m_resource_view->InitItemsFormNode(m_resource_view->GetRootNode()));
}
return true;
}
bool Leviathan_Editor::_setupSceneRuntimeObjectView()
{
m_runtime_object_view.reset(new LevSceneObjectTreeView);
return true;
}
bool Leviathan_Editor::_setupAttributePanelView()
{
m_attribute_view.reset(new LevAttributeWidget);
return true;
}
| 22.553846 | 101 | 0.75648 | wakare |
a2a8db066a24c9703388246c07a9656f7ca23c20 | 3,544 | cpp | C++ | nmpc_controller/test/test_nmpc_controller.cpp | robomechanics/quad-software | 89154df18e98162249f38301b669df27ee595220 | [
"MIT"
] | 20 | 2021-12-05T03:40:28.000Z | 2022-03-30T02:53:56.000Z | nmpc_controller/test/test_nmpc_controller.cpp | robomechanics/rml-spirit-firmware | 89154df18e98162249f38301b669df27ee595220 | [
"MIT"
] | 45 | 2021-12-06T12:45:05.000Z | 2022-03-31T22:15:47.000Z | nmpc_controller/test/test_nmpc_controller.cpp | robomechanics/rml-spirit-firmware | 89154df18e98162249f38301b669df27ee595220 | [
"MIT"
] | 2 | 2021-12-06T03:20:15.000Z | 2022-02-20T04:19:41.000Z | #include <gtest/gtest.h>
#include <ros/ros.h>
#include <chrono>
#include "nmpc_controller/nmpc_controller.h"
TEST(NMPCTest, testNMPCController) {
ros::NodeHandle nh;
const int robot_id_ = 0;
int N_;
double dt_;
ros::param::get("/local_planner/horizon_length", N_);
ros::param::get("/local_planner/timestep", dt_);
std::shared_ptr<NMPCController> leg_planner_ =
std::make_shared<NMPCController>(nh, robot_id_);
Eigen::MatrixXd ref_body_plan_(N_, 12);
ref_body_plan_.fill(0);
ref_body_plan_.col(2).fill(0.3);
Eigen::MatrixXd foot_positions_body_(N_, 12);
Eigen::MatrixXd foot_positions_world_(N_, 12);
Eigen::MatrixXd foot_velocities_world_(N_, 12);
foot_velocities_world_.setZero();
for (size_t i = 0; i < N_; i++) {
foot_positions_body_.row(i) << 0.2263, 0.098, -0.3, 0.2263, -0.098, -0.3,
-0.2263, 0.098, -0.3, -0.2263, -0.098, -0.3;
foot_positions_world_.row(i) << 0.2263, 0.098, 0, -0.2263, 0.098, 0, 0.2263,
-0.098, 0, -0.2263, -0.098, 0;
}
// Load the current state
Eigen::VectorXd current_state_(12);
current_state_.fill(0);
current_state_(2) = 0.2;
current_state_(9) = 0;
std::vector<std::vector<bool>> adpative_contact_schedule_;
adpative_contact_schedule_.resize(N_);
for (size_t i = 0; i < N_; i++) {
adpative_contact_schedule_.at(i).resize(4);
if (i % 12 < 6) {
adpative_contact_schedule_.at(i) = {true, false, false, true};
} else {
adpative_contact_schedule_.at(i) = {false, true, true, false};
}
}
Eigen::VectorXd ref_ground_height(N_);
ref_ground_height.fill(0);
Eigen::MatrixXd body_plan_(N_, 12);
body_plan_.col(2).fill(0.3);
Eigen::MatrixXd grf_plan_(N_ - 1, 12);
grf_plan_.fill(0);
grf_plan_.col(2).fill(13.3 * 9.81 / 2);
grf_plan_.col(5).fill(13.3 * 9.81 / 2);
grf_plan_.col(8).fill(13.3 * 9.81 / 2);
grf_plan_.col(11).fill(13.3 * 9.81 / 2);
double first_element_duration = dt_;
bool same_plan_index = false;
std::chrono::steady_clock::time_point tic, toc;
tic = std::chrono::steady_clock::now();
Eigen::VectorXd joint_positions(12), joint_velocities(12), torques(12);
grid_map::GridMap map({"z_inpainted", "traversability"});
map.setGeometry(grid_map::Length(10, 10), 0.01);
for (grid_map::GridMapIterator it(map); !it.isPastEnd(); ++it) {
grid_map::Position position;
map.getPosition(*it, position);
map.at("z_inpainted", *it) = 0;
map.at("traversability", *it) = 1;
}
for (int i = 0; i < 10; i++) {
tic = std::chrono::steady_clock::now();
leg_planner_->computeLegPlan(
current_state_, ref_body_plan_, foot_positions_body_,
foot_positions_world_, foot_velocities_world_,
adpative_contact_schedule_, ref_ground_height, first_element_duration,
same_plan_index, map, body_plan_, grf_plan_);
toc = std::chrono::steady_clock::now();
std::cout << "Time difference = "
<< std::chrono::duration_cast<std::chrono::microseconds>(toc -
tic)
.count()
<< "[µs]" << std::endl;
current_state_ = body_plan_.block(1, 0, 1, 12).transpose();
std::rotate(adpative_contact_schedule_.begin(),
adpative_contact_schedule_.begin() + 1,
adpative_contact_schedule_.end());
}
EXPECT_TRUE(true);
}
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
ros::init(argc, argv, "nmpc_controller_tester");
return RUN_ALL_TESTS();
}
| 31.087719 | 80 | 0.642212 | robomechanics |
a2a9c96c8777d07da12b1305ec4436a2b6a3e3e5 | 8,667 | cpp | C++ | dynamorio/clients/drcachesim/tools/opcode_mix.cpp | andre-motta/Project3Compilers | fa366d93ec8d49768fbc86f0c1431391822baf12 | [
"MIT"
] | 107 | 2021-08-28T20:08:42.000Z | 2022-03-22T08:02:16.000Z | dynamorio/clients/drcachesim/tools/opcode_mix.cpp | andre-motta/Project3Compilers | fa366d93ec8d49768fbc86f0c1431391822baf12 | [
"MIT"
] | null | null | null | dynamorio/clients/drcachesim/tools/opcode_mix.cpp | andre-motta/Project3Compilers | fa366d93ec8d49768fbc86f0c1431391822baf12 | [
"MIT"
] | 16 | 2021-08-30T06:57:36.000Z | 2022-03-22T08:05:52.000Z | /* **********************************************************
* Copyright (c) 2017-2020 Google, Inc. All rights reserved.
* **********************************************************/
/*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of Google, Inc. nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
/* This trace analyzer requires access to the modules.log file and the
* libraries and binary from the traced execution in order to obtain further
* information about each instruction than was stored in the trace.
* It does not support online use, only offline.
*/
#include "dr_api.h"
#include "opcode_mix.h"
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
#include <string.h>
const std::string opcode_mix_t::TOOL_NAME = "Opcode mix tool";
analysis_tool_t *
opcode_mix_tool_create(const std::string &module_file_path, unsigned int verbose,
const std::string &alt_module_dir)
{
return new opcode_mix_t(module_file_path, verbose, alt_module_dir);
}
opcode_mix_t::opcode_mix_t(const std::string &module_file_path, unsigned int verbose,
const std::string &alt_module_dir)
: module_file_path_(module_file_path)
, knob_verbose_(verbose)
, knob_alt_module_dir_(alt_module_dir)
{
}
std::string
opcode_mix_t::initialize()
{
serial_shard_.worker = &serial_worker_;
if (module_file_path_.empty())
return "Module file path is missing";
dcontext_.dcontext = dr_standalone_init();
std::string error = directory_.initialize_module_file(module_file_path_);
if (!error.empty())
return "Failed to initialize directory: " + error;
module_mapper_ =
module_mapper_t::create(directory_.modfile_bytes_, nullptr, nullptr, nullptr,
nullptr, knob_verbose_, knob_alt_module_dir_);
module_mapper_->get_loaded_modules();
error = module_mapper_->get_last_error();
if (!error.empty())
return "Failed to load binaries: " + error;
return "";
}
opcode_mix_t::~opcode_mix_t()
{
for (auto &iter : shard_map_) {
delete iter.second;
}
}
bool
opcode_mix_t::parallel_shard_supported()
{
return true;
}
void *
opcode_mix_t::parallel_worker_init(int worker_index)
{
auto worker = new worker_data_t;
return reinterpret_cast<void *>(worker);
}
std::string
opcode_mix_t::parallel_worker_exit(void *worker_data)
{
worker_data_t *worker = reinterpret_cast<worker_data_t *>(worker_data);
delete worker;
return "";
}
void *
opcode_mix_t::parallel_shard_init(int shard_index, void *worker_data)
{
worker_data_t *worker = reinterpret_cast<worker_data_t *>(worker_data);
auto shard = new shard_data_t(worker);
std::lock_guard<std::mutex> guard(shard_map_mutex_);
shard_map_[shard_index] = shard;
return reinterpret_cast<void *>(shard);
}
bool
opcode_mix_t::parallel_shard_exit(void *shard_data)
{
// Nothing (we read the shard data in print_results).
return true;
}
bool
opcode_mix_t::parallel_shard_memref(void *shard_data, const memref_t &memref)
{
shard_data_t *shard = reinterpret_cast<shard_data_t *>(shard_data);
if (memref.marker.type == TRACE_TYPE_MARKER &&
memref.marker.marker_type == TRACE_MARKER_TYPE_FILETYPE) {
if (TESTANY(OFFLINE_FILE_TYPE_ARCH_ALL, memref.marker.marker_value) &&
!TESTANY(build_target_arch_type(), memref.marker.marker_value)) {
shard->error = std::string("Architecture mismatch: trace recorded on ") +
trace_arch_string(static_cast<offline_file_type_t>(
memref.marker.marker_value)) +
" but tool built for " + trace_arch_string(build_target_arch_type());
return false;
}
}
if (!type_is_instr(memref.instr.type) &&
memref.data.type != TRACE_TYPE_INSTR_NO_FETCH) {
return true;
}
++shard->instr_count;
app_pc mapped_pc;
const app_pc trace_pc = reinterpret_cast<app_pc>(memref.instr.addr);
if (trace_pc >= shard->last_trace_module_start &&
static_cast<size_t>(trace_pc - shard->last_trace_module_start) <
shard->last_trace_module_size) {
mapped_pc =
shard->last_mapped_module_start + (trace_pc - shard->last_trace_module_start);
} else {
std::lock_guard<std::mutex> guard(mapper_mutex_);
mapped_pc = module_mapper_->find_mapped_trace_bounds(
trace_pc, &shard->last_mapped_module_start, &shard->last_trace_module_size);
if (!module_mapper_->get_last_error().empty()) {
shard->last_trace_module_start = nullptr;
shard->last_trace_module_size = 0;
shard->error = "Failed to find mapped address for " +
to_hex_string(memref.instr.addr) + ": " +
module_mapper_->get_last_error();
return false;
}
shard->last_trace_module_start =
trace_pc - (mapped_pc - shard->last_mapped_module_start);
}
int opcode;
auto cached_opcode = shard->worker->opcode_cache.find(mapped_pc);
if (cached_opcode != shard->worker->opcode_cache.end()) {
opcode = cached_opcode->second;
} else {
instr_t instr;
instr_init(dcontext_.dcontext, &instr);
app_pc next_pc = decode(dcontext_.dcontext, mapped_pc, &instr);
if (next_pc == NULL || !instr_valid(&instr)) {
shard->error =
"Failed to decode instruction " + to_hex_string(memref.instr.addr);
return false;
}
opcode = instr_get_opcode(&instr);
shard->worker->opcode_cache[mapped_pc] = opcode;
instr_free(dcontext_.dcontext, &instr);
}
++shard->opcode_counts[opcode];
return true;
}
std::string
opcode_mix_t::parallel_shard_error(void *shard_data)
{
shard_data_t *shard = reinterpret_cast<shard_data_t *>(shard_data);
return shard->error;
}
bool
opcode_mix_t::process_memref(const memref_t &memref)
{
if (!parallel_shard_memref(reinterpret_cast<void *>(&serial_shard_), memref)) {
error_string_ = serial_shard_.error;
return false;
}
return true;
}
static bool
cmp_val(const std::pair<int, int_least64_t> &l, const std::pair<int, int_least64_t> &r)
{
return (l.second > r.second);
}
bool
opcode_mix_t::print_results()
{
shard_data_t total(0);
if (shard_map_.empty()) {
total = serial_shard_;
} else {
for (const auto &shard : shard_map_) {
total.instr_count += shard.second->instr_count;
for (const auto &keyvals : shard.second->opcode_counts) {
total.opcode_counts[keyvals.first] += keyvals.second;
}
}
}
std::cerr << TOOL_NAME << " results:\n";
std::cerr << std::setw(15) << total.instr_count << " : total executed instructions\n";
std::vector<std::pair<int, int_least64_t>> sorted(total.opcode_counts.begin(),
total.opcode_counts.end());
std::sort(sorted.begin(), sorted.end(), cmp_val);
for (const auto &keyvals : sorted) {
std::cerr << std::setw(15) << keyvals.second << " : " << std::setw(9)
<< decode_opcode_name(keyvals.first) << "\n";
}
return true;
}
| 35.962656 | 90 | 0.668744 | andre-motta |
a2aa966718713660ac323fc856169bafe2a68e3d | 4,259 | cpp | C++ | src/chrono_vehicle/wheeled_vehicle/utils/ChWheeledVehicleAssembly.cpp | felixvd/chrono | 4c437fc1fc8964310d53206dda45e8ba9c734fa2 | [
"BSD-3-Clause"
] | null | null | null | src/chrono_vehicle/wheeled_vehicle/utils/ChWheeledVehicleAssembly.cpp | felixvd/chrono | 4c437fc1fc8964310d53206dda45e8ba9c734fa2 | [
"BSD-3-Clause"
] | null | null | null | src/chrono_vehicle/wheeled_vehicle/utils/ChWheeledVehicleAssembly.cpp | felixvd/chrono | 4c437fc1fc8964310d53206dda45e8ba9c734fa2 | [
"BSD-3-Clause"
] | null | null | null | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2014 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// Utility classes for wrapping a wheeled vehicle and powertrain system into a
// single assembly.
//
// =============================================================================
#include "chrono_vehicle/ChVehicleModelData.h"
#include "chrono_vehicle/wheeled_vehicle/utils/ChWheeledVehicleAssembly.h"
namespace chrono {
namespace vehicle {
// -----------------------------------------------------------------------------
// Constructor from given JSON specification files.
// The vehicle system is constructed within the specified system, using the
// given JSON specification files for the vehicle and powertrain subsystems.
// These files are assumed to be given relative to the Chrono::Vehicle data
// directory.
// -----------------------------------------------------------------------------
ChWheeledVehicleAssembly::ChWheeledVehicleAssembly(ChSystem* system,
const std::string& vehicle_def_filename,
const std::string& powertrain_def_filename)
: m_driver_cb(NULL), m_tire_cb(NULL), m_chassis_cb(NULL) {
// Create the vehicle and powertrain systems.
m_vehicle = chrono_types::make_shared<WheeledVehicle>(system, vehicle::GetDataFile(vehicle_def_filename));
m_powertrain = chrono_types::make_shared<SimplePowertrain>(vehicle::GetDataFile(powertrain_def_filename));
// The vector of tire forces is required by the ChronoVehicle API. Since we
// use rigid contact for tire-terrain interaction, these are always zero.
m_tire_forces.resize(2 * m_vehicle->GetNumberAxles());
}
// -----------------------------------------------------------------------------
// Initialize the vehicle model at the specified location and orientation.
// -----------------------------------------------------------------------------
void ChWheeledVehicleAssembly::Initialize(const ChVector<>& init_loc, const ChQuaternion<>& init_rot) {
// Initialize the vehicle and powertrain systems.
m_vehicle->Initialize(ChCoordsys<>(init_loc, init_rot));
m_powertrain->Initialize(m_vehicle->GetChassisBody(), m_vehicle->GetDriveshaft());
// If provided, invoke the user-specified callback to attach chassis contact
// geometry.
if (m_chassis_cb) {
std::shared_ptr<ChBodyAuxRef> chassisBody = m_vehicle->GetChassisBody();
m_chassis_cb->onCallback(chassisBody);
chassisBody->SetCollide(true);
}
// If provided, invoke the user-specified callback to attach tire contact
// geometry for each wheel of the vehicle.
if (m_tire_cb) {
for (int i = 0; i < 2 * m_vehicle->GetNumberAxles(); i++) {
std::shared_ptr<ChBody> wheelBody = m_vehicle->GetWheelBody(i);
m_tire_cb->onCallback(wheelBody);
wheelBody->SetCollide(true);
}
}
}
// -----------------------------------------------------------------------------
// Update the vehicle model at the specified time.
// -----------------------------------------------------------------------------
void ChWheeledVehicleAssembly::Synchronize(double time) {
// Invoke the user-provided callback to get driver inputs at current time.
double throttle = 0;
double steering = 0;
double braking = 0;
if (m_driver_cb)
m_driver_cb->onCallback(time, throttle, steering, braking);
// Update the powertrain system.
m_powertrain->Synchronize(time, throttle, m_vehicle->GetDriveshaftSpeed());
// Update the vehicle system.
m_vehicle->Synchronize(time, steering, braking, m_powertrain->GetOutputTorque(), m_tire_forces);
}
} // end namespace vehicle
} // namespace chrono
| 44.364583 | 110 | 0.577131 | felixvd |
a2ab09cce7e03cbb35a3257ee378bde0b4543c79 | 3,107 | cpp | C++ | Effects/Tools/CVarActivationSystem.cpp | IvarJonsson/Project-Unknown | 4675b41bbb5e90135c7bf3aded2c2e262b50f351 | [
"BSL-1.0"
] | null | null | null | Effects/Tools/CVarActivationSystem.cpp | IvarJonsson/Project-Unknown | 4675b41bbb5e90135c7bf3aded2c2e262b50f351 | [
"BSL-1.0"
] | null | null | null | Effects/Tools/CVarActivationSystem.cpp | IvarJonsson/Project-Unknown | 4675b41bbb5e90135c7bf3aded2c2e262b50f351 | [
"BSL-1.0"
] | null | null | null | // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
// Simple data driven system to activate cvars.
// Includes
#include "StdAfx.h"
#include "CVarActivationSystem.h"
#include "IItemSystem.h"
#include "Effects/GameEffectsSystem.h"
//--------------------------------------------------------------------------------------------------
// Name: Initialise
// Desc: Initialises cvar activation system from data
// Uses the xml node name for the cvar, and activeValue attribute
// eg <cl_fov activeValue="85"/>
//--------------------------------------------------------------------------------------------------
void CCVarActivationSystem::Initialise(const IItemParamsNode* cvarListXmlNode)
{
if(cvarListXmlNode)
{
const IItemParamsNode* cvarXmlNode = NULL;
SCVarParam* param = NULL;
int cvarCount = cvarListXmlNode->GetChildCount();
m_cvarParam.resize(cvarCount);
for(int i=0; i<cvarCount; i++)
{
param = &m_cvarParam[i];
cvarXmlNode = cvarListXmlNode->GetChild(i);
param->cvar = gEnv->pConsole->GetCVar(cvarXmlNode->GetName());
FX_ASSERT_MESSAGE(param->cvar,"Failed to find a CVAR for a game effect");
cvarXmlNode->GetAttribute("activeValue",param->activeValue);
param->originalValue = 0.0f;
}
}
}//-------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
// Name: Release
// Desc: Releases data used for CVar activation system
//--------------------------------------------------------------------------------------------------
void CCVarActivationSystem::Release()
{
m_cvarParam.Free();
}//-------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
// Name: StoreCurrentValues
// Desc: Stores current values of CVars
//--------------------------------------------------------------------------------------------------
void CCVarActivationSystem::StoreCurrentValues()
{
SCVarParam* param = NULL;
for(uint32 i=0; i<m_cvarParam.Size(); i++)
{
param = &m_cvarParam[i];
if(param->cvar)
{
param->originalValue = param->cvar->GetFVal();
}
}
}//-------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
// Name: SetCVarsActive
// Desc: Sets active status of cvars
//--------------------------------------------------------------------------------------------------
void CCVarActivationSystem::SetCVarsActive(bool isActive)
{
SCVarParam* param = NULL;
float value = 0.0f;
for(uint32 i=0; i<m_cvarParam.Size(); i++)
{
param = &m_cvarParam[i];
if(param->cvar)
{
if(isActive)
{
param->cvar->Set(param->activeValue);
}
else
{
param->cvar->Set(param->originalValue);
}
}
}
}//-------------------------------------------------------------------------------------------------
| 34.910112 | 100 | 0.429675 | IvarJonsson |
a2acb3efe2d9532fa8cefede51ad09f4d1beae04 | 22,126 | cpp | C++ | indra/newview/lllegacyatmospherics.cpp | SaladDais/LLUDP-Encryption | 8a426cd0dd154e1a10903e0e6383f4deb2a6098a | [
"ISC"
] | 1 | 2022-01-29T07:10:03.000Z | 2022-01-29T07:10:03.000Z | indra/newview/lllegacyatmospherics.cpp | bloomsirenix/Firestorm-manikineko | 67e1bb03b2d05ab16ab98097870094a8cc9de2e7 | [
"Unlicense"
] | null | null | null | indra/newview/lllegacyatmospherics.cpp | bloomsirenix/Firestorm-manikineko | 67e1bb03b2d05ab16ab98097870094a8cc9de2e7 | [
"Unlicense"
] | 1 | 2021-10-01T22:22:27.000Z | 2021-10-01T22:22:27.000Z | /**
* @file lllegacyatmospherics.cpp
* @brief LLAtmospherics class implementation
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "lllegacyatmospherics.h"
#include "llfeaturemanager.h"
#include "llviewercontrol.h"
#include "llframetimer.h"
#include "llagent.h"
#include "llagentcamera.h"
#include "lldrawable.h"
#include "llface.h"
#include "llglheaders.h"
#include "llsky.h"
#include "llviewercamera.h"
#include "llviewertexturelist.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
#include "llworld.h"
#include "pipeline.h"
#include "v3colorutil.h"
#include "llsettingssky.h"
#include "llenvironment.h"
#include "lldrawpoolwater.h"
class LLFastLn
{
public:
LLFastLn()
{
mTable[0] = 0;
for( S32 i = 1; i < 257; i++ )
{
mTable[i] = log((F32)i);
}
}
F32 ln( F32 x )
{
const F32 OO_255 = 0.003921568627450980392156862745098f;
const F32 LN_255 = 5.5412635451584261462455391880218f;
if( x < OO_255 )
{
return log(x);
}
else
if( x < 1 )
{
x *= 255.f;
S32 index = llfloor(x);
F32 t = x - index;
F32 low = mTable[index];
F32 high = mTable[index + 1];
return low + t * (high - low) - LN_255;
}
else
if( x <= 255 )
{
S32 index = llfloor(x);
F32 t = x - index;
F32 low = mTable[index];
F32 high = mTable[index + 1];
return low + t * (high - low);
}
else
{
return log( x );
}
}
F32 pow( F32 x, F32 y )
{
return (F32)LL_FAST_EXP(y * ln(x));
}
private:
F32 mTable[257]; // index 0 is unused
};
static LLFastLn gFastLn;
// Functions used a lot.
inline F32 LLHaze::calcPhase(const F32 cos_theta) const
{
const F32 g2 = mG * mG;
const F32 den = 1 + g2 - 2 * mG * cos_theta;
return (1 - g2) * gFastLn.pow(den, -1.5);
}
inline void color_pow(LLColor3 &col, const F32 e)
{
col.mV[0] = gFastLn.pow(col.mV[0], e);
col.mV[1] = gFastLn.pow(col.mV[1], e);
col.mV[2] = gFastLn.pow(col.mV[2], e);
}
inline LLColor3 color_norm(const LLColor3 &col)
{
const F32 m = color_max(col);
if (m > 1.f)
{
return 1.f/m * col;
}
else return col;
}
inline void color_gamma_correct(LLColor3 &col)
{
const F32 gamma_inv = 1.f/1.2f;
if (col.mV[0] != 0.f)
{
col.mV[0] = gFastLn.pow(col.mV[0], gamma_inv);
}
if (col.mV[1] != 0.f)
{
col.mV[1] = gFastLn.pow(col.mV[1], gamma_inv);
}
if (col.mV[2] != 0.f)
{
col.mV[2] = gFastLn.pow(col.mV[2], gamma_inv);
}
}
static LLColor3 calc_air_sca_sea_level()
{
static LLColor3 WAVE_LEN(675, 520, 445);
static LLColor3 refr_ind = refr_ind_calc(WAVE_LEN);
static LLColor3 n21 = refr_ind * refr_ind - LLColor3(1, 1, 1);
static LLColor3 n4 = n21 * n21;
static LLColor3 wl2 = WAVE_LEN * WAVE_LEN * 1e-6f;
static LLColor3 wl4 = wl2 * wl2;
static LLColor3 mult_const = fsigma * 2.0f/ 3.0f * 1e24f * (F_PI * F_PI) * n4;
static F32 dens_div_N = F32( ATM_SEA_LEVEL_NDENS / Ndens2);
return dens_div_N * mult_const.divide(wl4);
}
// static constants.
LLColor3 const LLHaze::sAirScaSeaLevel = calc_air_sca_sea_level();
F32 const LLHaze::sAirScaIntense = color_intens(LLHaze::sAirScaSeaLevel);
F32 const LLHaze::sAirScaAvg = LLHaze::sAirScaIntense / 3.f;
/***************************************
Atmospherics
***************************************/
LLAtmospherics::LLAtmospherics()
: mCloudDensity(0.2f),
mWind(0.f),
mWorldScale(1.f)
{
/// WL PARAMS
mInitialized = FALSE;
mAmbientScale = gSavedSettings.getF32("SkyAmbientScale");
mNightColorShift = gSavedSettings.getColor3("SkyNightColorShift");
mFogColor.mV[VRED] = mFogColor.mV[VGREEN] = mFogColor.mV[VBLUE] = 0.5f;
mFogColor.mV[VALPHA] = 0.0f;
mFogRatio = 1.2f;
mHazeConcentration = 0.f;
mInterpVal = 0.f;
}
LLAtmospherics::~LLAtmospherics()
{
}
void LLAtmospherics::init()
{
const F32 haze_int = color_intens(mHaze.calcSigSca(0));
mHazeConcentration = haze_int / (color_intens(mHaze.calcAirSca(0)) + haze_int);
mInitialized = true;
}
LLColor4 LLAtmospherics::calcSkyColorInDir(AtmosphericsVars& vars, const LLVector3 &dir, bool isShiny)
{
LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
return calcSkyColorInDir(psky, vars, dir, isShiny);
}
// This cubemap is used as "environmentMap" in indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
LLColor4 LLAtmospherics::calcSkyColorInDir(const LLSettingsSky::ptr_t &psky, AtmosphericsVars& vars, const LLVector3 &dir, bool isShiny)
{
F32 sky_saturation = 0.25f;
F32 land_saturation = 0.1f;
if (isShiny && dir.mV[VZ] < -0.02f)
{
LLColor4 col;
LLColor3 desat_fog = LLColor3(mFogColor);
F32 brightness = desat_fog.brightness();// NOTE: Linear brightness!
// So that shiny somewhat shows up at night.
if (brightness < 0.15f)
{
brightness = 0.15f;
desat_fog = smear(0.15f);
}
F32 greyscale_sat = brightness * (1.0f - land_saturation);
desat_fog = desat_fog * land_saturation + smear(greyscale_sat);
if (!gPipeline.canUseWindLightShaders())
{
col = LLColor4(desat_fog, 0.f);
}
else
{
col = LLColor4(desat_fog * 0.5f, 0.f);
}
float x = 1.0f-fabsf(-0.1f-dir.mV[VZ]);
x *= x;
col.mV[0] *= x*x;
col.mV[1] *= powf(x, 2.5f);
col.mV[2] *= x*x*x;
return col;
}
// undo OGL_TO_CFR_ROTATION and negate vertical direction.
LLVector3 Pn = LLVector3(-dir[1] , -dir[2], -dir[0]);
//calculates hazeColor
calcSkyColorWLVert(psky, Pn, vars);
if (isShiny)
{
F32 brightness = vars.hazeColor.brightness();
F32 greyscale_sat = brightness * (1.0f - sky_saturation);
LLColor3 sky_color = vars.hazeColor * sky_saturation + smear(greyscale_sat);
//sky_color *= (0.5f + 0.5f * brightness); // SL-12574 EEP sky is being attenuated too much
return LLColor4(sky_color, 0.0f);
}
bool low_end = !gPipeline.canUseWindLightShaders();
LLColor3 sky_color = low_end ? vars.hazeColor * 2.0f : psky->gammaCorrect(vars.hazeColor * 2.0f);
return LLColor4(sky_color, 0.0f);
}
// NOTE: Keep these in sync!
// indra\newview\app_settings\shaders\class1\deferred\skyV.glsl
// indra\newview\app_settings\shaders\class1\deferred\cloudsV.glsl
// indra\newview\lllegacyatmospherics.cpp
void LLAtmospherics::calcSkyColorWLVert(const LLSettingsSky::ptr_t &psky, LLVector3 & Pn, AtmosphericsVars& vars)
{
LLColor3 blue_density = vars.blue_density;
LLColor3 blue_horizon = vars.blue_horizon;
F32 haze_horizon = vars.haze_horizon;
F32 haze_density = vars.haze_density;
F32 density_multiplier = vars.density_multiplier;
F32 max_y = vars.max_y;
LLVector4 sun_norm = vars.sun_norm;
// project the direction ray onto the sky dome.
F32 phi = acos(Pn[1]);
F32 sinA = sin(F_PI - phi);
if (fabsf(sinA) < 0.01f)
{ //avoid division by zero
sinA = 0.01f;
}
F32 Plen = vars.dome_radius * sin(F_PI + phi + asin(vars.dome_offset * sinA)) / sinA;
Pn *= Plen;
// Set altitude
if (Pn[1] > 0.f)
{
Pn *= (max_y / Pn[1]);
}
else
{
Pn *= (-32000.f / Pn[1]);
}
Plen = Pn.length();
Pn /= Plen;
// Initialize temp variables
LLColor3 sunlight = vars.sunlight;
LLColor3 ambient = vars.ambient;
LLColor3 glow = vars.glow;
F32 cloud_shadow = vars.cloud_shadow;
// Sunlight attenuation effect (hue and brightness) due to atmosphere
// this is used later for sunlight modulation at various altitudes
LLColor3 light_atten = vars.light_atten;
LLColor3 light_transmittance = psky->getLightTransmittance(Plen);
(void)light_transmittance; // silence Clang warn-error
// Calculate relative weights
LLColor3 temp2(0.f, 0.f, 0.f);
LLColor3 temp1 = vars.total_density;
LLColor3 blue_weight = componentDiv(blue_density, temp1);
LLColor3 blue_factor = blue_horizon * blue_weight;
LLColor3 haze_weight = componentDiv(smear(haze_density), temp1);
LLColor3 haze_factor = haze_horizon * haze_weight;
// Compute sunlight from P & lightnorm (for long rays like sky)
temp2.mV[1] = llmax(F_APPROXIMATELY_ZERO, llmax(0.f, Pn[1]) * 1.0f + sun_norm.mV[1] );
temp2.mV[1] = 1.f / temp2.mV[1];
componentMultBy(sunlight, componentExp((light_atten * -1.f) * temp2.mV[1]));
componentMultBy(sunlight, light_transmittance);
// Distance
temp2.mV[2] = Plen * density_multiplier;
// Transparency (-> temp1)
temp1 = componentExp((temp1 * -1.f) * temp2.mV[2]);
// Compute haze glow
temp2.mV[0] = Pn * LLVector3(sun_norm);
temp2.mV[0] = 1.f - temp2.mV[0];
// temp2.x is 0 at the sun and increases away from sun
temp2.mV[0] = llmax(temp2.mV[0], .001f);
// Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
// Higher glow.x gives dimmer glow (because next step is 1 / "angle")
temp2.mV[0] *= glow.mV[0];
temp2.mV[0] = pow(temp2.mV[0], glow.mV[2]);
// glow.z should be negative, so we're doing a sort of (1 / "angle") function
// Add "minimum anti-solar illumination"
temp2.mV[0] += .25f;
// Haze color above cloud
vars.hazeColor = (blue_factor * (sunlight + ambient) + componentMult(haze_factor, sunlight * temp2.mV[0] + ambient));
// Increase ambient when there are more clouds
LLColor3 tmpAmbient = ambient + (LLColor3::white - ambient) * cloud_shadow * 0.5f;
// Dim sunlight by cloud shadow percentage
sunlight *= (1.f - cloud_shadow);
// Haze color below cloud
vars.hazeColorBelowCloud = (blue_factor * (sunlight + tmpAmbient) + componentMult(haze_factor, sunlight * temp2.mV[0] + tmpAmbient));
// Final atmosphere additive
componentMultBy(vars.hazeColor, LLColor3::white - temp1);
/*
// SL-12574
// Attenuate cloud color by atmosphere
temp1 = componentSqrt(temp1); //less atmos opacity (more transparency) below clouds
// At horizon, blend high altitude sky color towards the darker color below the clouds
vars.hazeColor += componentMult(vars.hazeColorBelowCloud - vars.hazeColor, LLColor3::white - componentSqrt(temp1));
*/
}
void LLAtmospherics::updateFog(const F32 distance, const LLVector3& tosun_in)
{
LLVector3 tosun = tosun_in;
if (!gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOG))
{
if (!LLGLSLShader::sNoFixedFunction)
{
glFogf(GL_FOG_DENSITY, 0);
glFogfv(GL_FOG_COLOR, (F32 *) &LLColor4::white.mV);
glFogf(GL_FOG_END, 1000000.f);
}
return;
}
const BOOL hide_clip_plane = TRUE;
LLColor4 target_fog(0.f, 0.2f, 0.5f, 0.f);
const F32 water_height = gAgent.getRegion() ? gAgent.getRegion()->getWaterHeight() : 0.f;
// LLWorld::getInstance()->getWaterHeight();
F32 camera_height = gAgentCamera.getCameraPositionAgent().mV[2];
F32 near_clip_height = LLViewerCamera::getInstance()->getAtAxis().mV[VZ] * LLViewerCamera::getInstance()->getNear();
camera_height += near_clip_height;
F32 fog_distance = 0.f;
LLColor3 res_color[3];
LLColor3 sky_fog_color = LLColor3::white;
LLColor3 render_fog_color = LLColor3::white;
const F32 tosun_z = tosun.mV[VZ];
tosun.mV[VZ] = 0.f;
tosun.normalize();
LLVector3 perp_tosun;
perp_tosun.mV[VX] = -tosun.mV[VY];
perp_tosun.mV[VY] = tosun.mV[VX];
LLVector3 tosun_45 = tosun + perp_tosun;
tosun_45.normalize();
F32 delta = 0.06f;
tosun.mV[VZ] = delta;
perp_tosun.mV[VZ] = delta;
tosun_45.mV[VZ] = delta;
tosun.normalize();
perp_tosun.normalize();
tosun_45.normalize();
// Sky colors, just slightly above the horizon in the direction of the sun, perpendicular to the sun, and at a 45 degree angle to the sun.
AtmosphericsVars vars;
LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
// invariants across whole sky tex process...
vars.blue_density = psky->getBlueDensity();
vars.blue_horizon = psky->getBlueHorizon();
vars.haze_density = psky->getHazeDensity();
vars.haze_horizon = psky->getHazeHorizon();
vars.density_multiplier = psky->getDensityMultiplier();
vars.distance_multiplier = psky->getDistanceMultiplier();
vars.max_y = psky->getMaxY();
vars.sun_norm = LLEnvironment::instance().getSunDirectionCFR();
vars.sunlight = psky->getSunlightColor();
vars.ambient = psky->getAmbientColor();
vars.glow = psky->getGlow();
vars.cloud_shadow = psky->getCloudShadow();
vars.dome_radius = psky->getDomeRadius();
vars.dome_offset = psky->getDomeOffset();
vars.light_atten = psky->getLightAttenuation(vars.max_y);
vars.light_transmittance = psky->getLightTransmittance(vars.max_y);
vars.total_density = psky->getTotalDensity();
vars.gamma = psky->getGamma();
res_color[0] = calcSkyColorInDir(vars, tosun);
res_color[1] = calcSkyColorInDir(vars, perp_tosun);
res_color[2] = calcSkyColorInDir(vars, tosun_45);
sky_fog_color = color_norm(res_color[0] + res_color[1] + res_color[2]);
F32 full_off = -0.25f;
F32 full_on = 0.00f;
F32 on = (tosun_z - full_off) / (full_on - full_off);
on = llclamp(on, 0.01f, 1.f);
sky_fog_color *= 0.5f * on;
// We need to clamp these to non-zero, in order for the gamma correction to work. 0^y = ???
S32 i;
for (i = 0; i < 3; i++)
{
sky_fog_color.mV[i] = llmax(0.0001f, sky_fog_color.mV[i]);
}
color_gamma_correct(sky_fog_color);
render_fog_color = sky_fog_color;
F32 fog_density = 0.f;
fog_distance = mFogRatio * distance;
if (camera_height > water_height)
{
LLColor4 fog(render_fog_color);
if (!LLGLSLShader::sNoFixedFunction)
{
glFogfv(GL_FOG_COLOR, fog.mV);
}
mGLFogCol = fog;
if (hide_clip_plane)
{
// For now, set the density to extend to the cull distance.
const F32 f_log = 2.14596602628934723963618357029f; // sqrt(fabs(log(0.01f)))
fog_density = f_log/fog_distance;
if (!LLGLSLShader::sNoFixedFunction)
{
glFogi(GL_FOG_MODE, GL_EXP2);
}
}
else
{
const F32 f_log = 4.6051701859880913680359829093687f; // fabs(log(0.01f))
fog_density = (f_log)/fog_distance;
if (!LLGLSLShader::sNoFixedFunction)
{
glFogi(GL_FOG_MODE, GL_EXP);
}
}
}
else
{
LLSettingsWater::ptr_t pwater = LLEnvironment::instance().getCurrentWater();
F32 depth = water_height - camera_height;
// get the water param manager variables
float water_fog_density = pwater->getModifiedWaterFogDensity(depth <= 0.0f);
LLColor4 water_fog_color(pwater->getWaterFogColor());
// adjust the color based on depth. We're doing linear approximations
float depth_scale = gSavedSettings.getF32("WaterGLFogDepthScale");
float depth_modifier = 1.0f - llmin(llmax(depth / depth_scale, 0.01f),
gSavedSettings.getF32("WaterGLFogDepthFloor"));
LLColor4 fogCol = water_fog_color * depth_modifier;
fogCol.setAlpha(1);
// set the gl fog color
mGLFogCol = fogCol;
// set the density based on what the shaders use
fog_density = water_fog_density * gSavedSettings.getF32("WaterGLFogDensityScale");
if (!LLGLSLShader::sNoFixedFunction)
{
glFogfv(GL_FOG_COLOR, (F32 *) &fogCol.mV);
glFogi(GL_FOG_MODE, GL_EXP2);
}
}
mFogColor = sky_fog_color;
mFogColor.setAlpha(1);
LLDrawPoolWater::sWaterFogEnd = fog_distance*2.2f;
if (!LLGLSLShader::sNoFixedFunction)
{
LLGLSFog gls_fog;
glFogf(GL_FOG_END, fog_distance*2.2f);
glFogf(GL_FOG_DENSITY, fog_density);
glHint(GL_FOG_HINT, GL_NICEST);
}
stop_glerror();
}
// Functions used a lot.
F32 color_norm_pow(LLColor3& col, F32 e, BOOL postmultiply)
{
F32 mv = color_max(col);
if (0 == mv)
{
return 0;
}
col *= 1.f / mv;
color_pow(col, e);
if (postmultiply)
{
col *= mv;
}
return mv;
}
// Returns angle (RADIANs) between the horizontal projection of "v" and the x_axis.
// Range of output is 0.0f to 2pi //359.99999...f
// Returns 0.0f when "v" = +/- z_axis.
F32 azimuth(const LLVector3 &v)
{
F32 azimuth = 0.0f;
if (v.mV[VX] == 0.0f)
{
if (v.mV[VY] > 0.0f)
{
azimuth = F_PI * 0.5f;
}
else if (v.mV[VY] < 0.0f)
{
azimuth = F_PI * 1.5f;// 270.f;
}
}
else
{
azimuth = (F32) atan(v.mV[VY] / v.mV[VX]);
if (v.mV[VX] < 0.0f)
{
azimuth += F_PI;
}
else if (v.mV[VY] < 0.0f)
{
azimuth += F_PI * 2;
}
}
return azimuth;
}
bool operator==(const AtmosphericsVars& a, const AtmosphericsVars& b)
{
if (a.hazeColor != b.hazeColor)
{
return false;
}
if (a.hazeColorBelowCloud != b.hazeColorBelowCloud)
{
return false;
}
if (a.cloudColorSun != b.cloudColorSun)
{
return false;
}
if (a.cloudColorAmbient != b.cloudColorAmbient)
{
return false;
}
if (a.cloudDensity != b.cloudDensity)
{
return false;
}
if (a.density_multiplier != b.density_multiplier)
{
return false;
}
if (a.haze_horizon != b.haze_horizon)
{
return false;
}
if (a.haze_density != b.haze_density)
{
return false;
}
if (a.blue_horizon != b.blue_horizon)
{
return false;
}
if (a.blue_density != b.blue_density)
{
return false;
}
if (a.dome_offset != b.dome_offset)
{
return false;
}
if (a.dome_radius != b.dome_radius)
{
return false;
}
if (a.cloud_shadow != b.cloud_shadow)
{
return false;
}
if (a.glow != b.glow)
{
return false;
}
if (a.ambient != b.ambient)
{
return false;
}
if (a.sunlight != b.sunlight)
{
return false;
}
if (a.sun_norm != b.sun_norm)
{
return false;
}
if (a.gamma != b.gamma)
{
return false;
}
if (a.max_y != b.max_y)
{
return false;
}
if (a.distance_multiplier != b.distance_multiplier)
{
return false;
}
// light_atten, light_transmittance, total_density
// are ignored as they always change when the values above do
// they're just shared calc across the sky map generation to save cycles
return true;
}
bool approximatelyEqual(const F32 &a, const F32 &b, const F32 &fraction_treshold)
{
F32 diff = fabs(a - b);
if (diff < F_APPROXIMATELY_ZERO || diff < llmax(fabs(a), fabs(b)) * fraction_treshold)
{
return true;
}
return false;
}
bool approximatelyEqual(const LLColor3 &a, const LLColor3 &b, const F32 &fraction_treshold)
{
return approximatelyEqual(a.mV[0], b.mV[0], fraction_treshold)
&& approximatelyEqual(a.mV[1], b.mV[1], fraction_treshold)
&& approximatelyEqual(a.mV[2], b.mV[2], fraction_treshold);
}
bool approximatelyEqual(const LLVector4 &a, const LLVector4 &b, const F32 &fraction_treshold)
{
return approximatelyEqual(a.mV[0], b.mV[0], fraction_treshold)
&& approximatelyEqual(a.mV[1], b.mV[1], fraction_treshold)
&& approximatelyEqual(a.mV[2], b.mV[2], fraction_treshold)
&& approximatelyEqual(a.mV[3], b.mV[3], fraction_treshold);
}
bool approximatelyEqual(const AtmosphericsVars& a, const AtmosphericsVars& b, const F32 fraction_treshold)
{
if (!approximatelyEqual(a.hazeColor, b.hazeColor, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.hazeColorBelowCloud, b.hazeColorBelowCloud, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.cloudColorSun, b.cloudColorSun, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.cloudColorAmbient, b.cloudColorAmbient, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.cloudDensity, b.cloudDensity, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.density_multiplier, b.density_multiplier, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.haze_horizon, b.haze_horizon, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.haze_density, b.haze_density, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.blue_horizon, b.blue_horizon, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.blue_density, b.blue_density, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.dome_offset, b.dome_offset, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.dome_radius, b.dome_radius, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.cloud_shadow, b.cloud_shadow, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.glow, b.glow, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.ambient, b.ambient, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.sunlight, b.sunlight, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.sun_norm, b.sun_norm, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.gamma, b.gamma, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.max_y, b.max_y, fraction_treshold))
{
return false;
}
if (!approximatelyEqual(a.distance_multiplier, b.distance_multiplier, fraction_treshold))
{
return false;
}
// light_atten, light_transmittance, total_density
// are ignored as they always change when the values above do
// they're just shared calc across the sky map generation to save cycles
return true;
}
| 25.908665 | 139 | 0.670343 | SaladDais |
a2aea435a00c9958982569042c2b3a366c8dec1e | 36,981 | hh | C++ | cc/json-importer.hh | acorg/acmacs-base | a1a6e5b346ea3746f3fc1750ed4b7f29c7c0d049 | [
"MIT"
] | null | null | null | cc/json-importer.hh | acorg/acmacs-base | a1a6e5b346ea3746f3fc1750ed4b7f29c7c0d049 | [
"MIT"
] | null | null | null | cc/json-importer.hh | acorg/acmacs-base | a1a6e5b346ea3746f3fc1750ed4b7f29c7c0d049 | [
"MIT"
] | null | null | null | #pragma once
#error Obsolete, use rjson
#include <string>
#include <vector>
#include <map>
#include <stack>
#include <typeinfo>
#include <functional>
#include <iostream>
#include <memory>
#include "acmacs-base/rapidjson.hh"
// ----------------------------------------------------------------------
namespace json_importer
{
class EventHandler;
namespace storers {
class Base
{
public:
virtual ~Base() {}
virtual Base* StartObject();
virtual Base* EndObject();
virtual Base* StartArray();
virtual Base* EndArray();
virtual Base* Key(const char* str, rapidjson::SizeType length);
virtual Base* String(const char* str, rapidjson::SizeType length);
virtual Base* Int(int i);
virtual Base* Uint(unsigned u);
virtual Base* Double(double d);
virtual Base* Bool(bool b);
virtual Base* Null();
virtual Base* Int64(int64_t i);
virtual Base* Uint64(uint64_t u);
}; // class Base
namespace _i {
class Msg : public Base
{
public:
enum Tag { Failure, Pop, Pop2 };
static Msg sMsg;
void failure(std::string aMessage) { mTag = Failure; mMessage = aMessage; }
void pop() { mTag = Pop; }
void pop2() { mTag = Pop2; }
void report() const { if (mTag == Failure && !mMessage.empty()) std::cerr << "ERROR: " << mMessage << std::endl; }
bool is_failure() const { return mTag == Failure; }
bool is_pop() const { return mTag == Pop; }
bool is_pop2() const { return mTag == Pop2; }
private:
Msg() : mTag(Failure) {}
Tag mTag;
std::string mMessage;
};
class Failure : public std::runtime_error { public: using std::runtime_error::runtime_error; Failure() : std::runtime_error{""} {} };
class Pop : public std::exception { public: using std::exception::exception; };
class Pop2 : public std::exception { public: using std::exception::exception; };
inline Msg* failure(std::string aMessage) { throw Failure(aMessage); }
inline Msg* pop() { throw Pop(); }
inline Msg* pop2() { throw Pop2(); }
} // namespace _i
inline Base* Base::StartObject() { return _i::failure(typeid(*this).name() + std::string("::StartObject")); }
inline Base* Base::EndObject() { return _i::failure(typeid(*this).name() + std::string("::EndObject")); } // { throw Pop(); }
inline Base* Base::StartArray() { return _i::failure(typeid(*this).name() + std::string("::StartArray")); }
inline Base* Base::EndArray() { return _i::failure(typeid(*this).name() + std::string("::EndArray")); } // { throw Pop(); }
inline Base* Base::Key(const char* str, rapidjson::SizeType length) { return _i::failure(typeid(*this).name() + std::string("::Key \"") + std::string(str, length) + "\""); }
inline Base* Base::String(const char* str, rapidjson::SizeType length) { return _i::failure(typeid(*this).name() + std::string("::String \"") + std::string(str, length) + "\""); }
inline Base* Base::Int(int i) { return _i::failure(typeid(*this).name() + std::string("::Int ") + std::to_string(i)); }
inline Base* Base::Uint(unsigned u) { return _i::failure(typeid(*this).name() + std::string("::Uint ") + std::to_string(u)); }
inline Base* Base::Double(double d) { return _i::failure(typeid(*this).name() + std::string("::Double ") + std::to_string(d)); }
inline Base* Base::Bool(bool b) { return _i::failure(typeid(*this).name() + std::string("::Bool ") + std::to_string(b)); }
inline Base* Base::Null() { return _i::failure(typeid(*this).name() + std::string("::Null")); }
inline Base* Base::Int64(int64_t i) { return _i::failure(typeid(*this).name() + std::string("::Int64 ") + std::to_string(i)); }
inline Base* Base::Uint64(uint64_t u) { return _i::failure(typeid(*this).name() + std::string("::Uint64 ") + std::to_string(u)); }
template <typename F> class Storer : public Base
{
public:
Storer(F aStorage) : mStorage(aStorage) {}
protected:
virtual Base* pop() { return nullptr; }
template <typename ...Args> Base* store(Args... args) { mStorage(args...); return pop(); }
F& storage() { return mStorage; }
private:
F mStorage;
};
template <typename F> class StringLength : public Storer<F>
{
public:
using Storer<F>::Storer;
virtual Base* String(const char* str, rapidjson::SizeType length) { return this->store(str, length); }
};
template <typename F> class Double_ : public Storer<F>
{
public:
using Storer<F>::Storer;
virtual Base* Double(double d) { return this->store(d); }
virtual Base* Int(int i) { return this->store(static_cast<double>(i)); }
virtual Base* Uint(unsigned u) { return this->store(static_cast<double>(u)); }
};
template <typename F> class Unsigned_ : public Storer<F>
{
public:
using Storer<F>::Storer;
virtual Base* Uint(unsigned u) { return this->store(u); }
virtual Base* Int(int i) { if (i == -1) return this->store(static_cast<unsigned>(i)); else return Storer<F>::Int(i); } // to read -1 for some size_t fields
};
template <typename F> class Int_ : public Storer<F>
{
public:
using Storer<F>::Storer;
virtual Base* Int(int i) { return this->store(i); }
virtual Base* Uint(unsigned u) { return Int(static_cast<int>(u)); }
};
template <typename F> class Bool_ : public Storer<F>
{
public:
using Storer<F>::Storer;
virtual Base* Bool(bool b) { return this->store(b); }
// virtual Base* Int(int i) { return Bool(i != 0); }
virtual Base* Uint(unsigned u) { return Bool(u != 0); }
};
// ----------------------------------------------------------------------
// Type detector functions
// They are never called but used by field(std::vector<Field>& (Parent::*accessor)()) and reader(void(T::*setter)(V), T& target) functions below to infer of the storer's type
// ----------------------------------------------------------------------
template <typename F> inline Unsigned_<F> type_detector(size_t) { throw std::exception{}; }
template <typename F> inline Unsigned_<F> type_detector(unsigned) { throw std::exception{}; }
template <typename F> inline Int_<F> type_detector(int) { throw std::exception{}; }
template <typename F> inline Double_<F> type_detector(double) { throw std::exception{}; }
template <typename F> inline Bool_<F> type_detector(bool) { throw std::exception{}; }
template <typename F> inline StringLength<F> type_detector(std::string) { throw std::exception{}; }
// ----------------------------------------------------------------------
// to be used as template parameter F for the above to store Array values
// ----------------------------------------------------------------------
template <typename Target> class ArrayElement
{
public:
ArrayElement(std::vector<Target>& aTarget) : mTarget(aTarget) {}
// void operator()(Target aValue) { mTarget.emplace_back(aValue); }
// void operator()(const char* str, size_t length) { mTarget.emplace_back(str, length); }
template <typename ...Args> void operator()(Args ...args) { mTarget.emplace_back(args...); }
private:
std::vector<Target>& mTarget;
};
template <typename Target> class ArrayOfArrayElementTarget
{
public:
ArrayOfArrayElementTarget(Target& aTarget) : mTarget(aTarget) {}
// void operator()(Target aValue) { mTarget.back().emplace_back(aValue); }
template <typename ...Args> void operator()(Args ...args) { mTarget.back().emplace_back(args...); }
size_t size() const { return mTarget.size(); }
void clear() { mTarget.clear(); }
void new_nested() { mTarget.emplace_back(); }
private:
Target& mTarget;
};
template <typename Target> using ArrayOfArrayElement = ArrayOfArrayElementTarget<std::vector<std::vector<Target>>>;
// ----------------------------------------------------------------------
// storer ignoring value
// ----------------------------------------------------------------------
class Ignore : public Base
{
public:
Ignore() : mNesting(0) {}
Base* pop() { if (mNesting == 0) return _i::pop(); else return nullptr; }
Base* decr() { --mNesting; return pop(); }
virtual Base* StartObject() { ++mNesting; return nullptr; }
virtual Base* EndObject() { return decr(); }
virtual Base* StartArray() { ++mNesting; return nullptr; }
virtual Base* EndArray() { return decr(); }
virtual Base* Key(const char*, rapidjson::SizeType) { return nullptr; }
virtual Base* String(const char*, rapidjson::SizeType) { return pop(); }
virtual Base* Int(int) { return pop(); }
virtual Base* Uint(unsigned) { return pop(); }
virtual Base* Double(double) { return pop(); }
virtual Base* Bool(bool) { return pop(); }
virtual Base* Null() { return pop(); }
virtual Base* Int64(int64_t) { return pop(); }
virtual Base* Uint64(uint64_t) { return pop(); }
private:
size_t mNesting;
};
} // namespace storers
// ----------------------------------------------------------------------
namespace readers {
using Base = storers::Base;
// ----------------------------------------------------------------------
// reader: Object
// ----------------------------------------------------------------------
template <typename Target> class Object : public Base
{
public:
Object(Target aTarget, bool aStarted = false) : mTarget(aTarget), mStarted(aStarted) {}
virtual Base* Key(const char* str, rapidjson::SizeType length)
{
if (!mStarted)
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected Key event"));
Base* r = match_key(str, length);
if (!r) {
if (length > 0 && (str[0] == '?' || str[length - 1] == '?'))
r = new storers::Ignore{}; // support for keys starting or ending with ? and "_"
else
r = Base::Key(str, length);
}
// else
// std::cerr << "readers::Object " << std::string(str, length) << " -> PUSH " << typeid(*r).name() << std::endl;
return r;
}
virtual Base* StartObject()
{
if (mStarted)
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected StartObject event"));
mStarted = true;
return nullptr;
}
virtual Base* EndObject()
{
return storers::_i::pop();
}
protected:
virtual Base* match_key(const char* str, rapidjson::SizeType length) = 0;
Target& target() { return mTarget; }
private:
Target mTarget;
bool mStarted;
};
// ----------------------------------------------------------------------
// reader: value storer
// ----------------------------------------------------------------------
template <typename ValueStorer> class Value : public ValueStorer
{
public:
using ValueStorer::ValueStorer;
protected:
virtual Base* pop() { return storers::_i::pop(); }
};
// ----------------------------------------------------------------------
// reader maker base
// ----------------------------------------------------------------------
namespace makers
{
template <typename Parent> class Base
{
public:
Base() = default;
virtual ~Base() {}
virtual readers::Base* reader(Parent& parent) = 0;
};
} // namespace makers
// ----------------------------------------------------------------------
// Structure to keep object reader description
// ----------------------------------------------------------------------
template <typename Parent> using data = std::map<std::string,std::shared_ptr<makers::Base<Parent>>>; // cannot have unique_ptr here because std::map requires copying
// ----------------------------------------------------------------------
// reader: DataRef
// ----------------------------------------------------------------------
template <typename Target> class DataRef : public Object<Target&>
{
public:
DataRef(Target& aTarget, data<Target>& aData, bool aStarted = false) : Object<Target&>(aTarget, aStarted), mData(aData) {}
protected:
virtual readers::Base* match_key(const char* str, rapidjson::SizeType length)
{
const std::string k{str, length};
// std::cerr << typeid(*this).name() << " " << k << std::endl;
auto e = mData.find(k);
if (e != mData.end())
// return e->second(this->target());
return e->second->reader(this->target());
return nullptr;
}
private:
data<Target>& mData;
}; // class DataRef<Target>
// ----------------------------------------------------------------------
// reader: ArrayOfObjects
// ----------------------------------------------------------------------
template <typename Element> class ArrayOfObjects : public Base
{
public:
ArrayOfObjects(std::vector<Element>& aArray, data<Element>& aData) : mArray(aArray), mData(aData), mStarted(false) {}
virtual Base* StartArray()
{
if (mStarted)
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected StartArray event"));
mStarted = true;
mArray.clear(); // erase all old elements
return nullptr;
}
virtual Base* EndArray()
{
// std::cerr << "EndArray of " << typeid(Element).name() << " elements:" << mArray.size() << std::endl;
return storers::_i::pop();
}
virtual Base* StartObject()
{
if (!mStarted)
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected StartObject event"));
mArray.emplace_back();
return new DataRef<Element>(mArray.back(), mData, true);
}
private:
std::vector<Element>& mArray;
data<Element>& mData;
bool mStarted;
}; // class ArrayOfObjects<Element>
// ----------------------------------------------------------------------
// reader: ArrayOfValues
// ----------------------------------------------------------------------
template <typename Element, typename Storer> class ArrayOfValues : public Storer
{
public:
ArrayOfValues(std::vector<Element>& aArray) : Storer(aArray), mArray(aArray), mStarted(false) {}
virtual Base* StartArray()
{
if (mStarted)
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected StartArray event"));
mStarted = true;
mArray.clear(); // erase all old elements
return nullptr;
}
virtual Base* EndArray()
{
return storers::_i::pop();
}
private:
std::vector<Element>& mArray;
bool mStarted;
}; // class ArrayOfValues<Element>
// ----------------------------------------------------------------------
// reader: ArrayOfArrayOfValues
// ----------------------------------------------------------------------
template <typename Target, typename Storer> class ArrayOfArrayOfValuesTarget : public Storer
{
public:
ArrayOfArrayOfValuesTarget(Target& aArray) : Storer(aArray), mNesting(0) {}
virtual Base* StartArray()
{
switch (mNesting) {
case 0:
this->storage().clear(); // erase all old elements
break;
case 1:
this->storage().new_nested();
break;
default:
return storers::_i::failure(typeid(*this).name() + std::string(": unexpected StartArray event"));
}
++mNesting;
return nullptr;
}
virtual Base* EndArray()
{
switch (mNesting) {
case 1:
return storers::_i::pop();
case 2:
break;
default:
return storers::_i::failure(typeid(*this).name() + std::string(": internal, EndArray event with nesting ") + std::to_string(mNesting));
}
--mNesting;
return nullptr;
}
private:
size_t mNesting;
}; // class ArrayOfArrayOfValuesTarget<Target, Storer>
template <typename Element, typename Storer> using ArrayOfArrayOfValues = ArrayOfArrayOfValuesTarget<std::vector<std::vector<Element>>, Storer>;
// ----------------------------------------------------------------------
// reader: template helpers
// ----------------------------------------------------------------------
template <typename T> inline Base* reader(void(T::*setter)(const char*, size_t), T& target)
{
using Bind = decltype(std::bind(setter, &target, std::placeholders::_1, std::placeholders::_2));
return new Value<storers::StringLength<Bind>>(std::bind(setter, &target, std::placeholders::_1, std::placeholders::_2));
}
template <typename T, typename V> inline Base* reader(void(T::*setter)(V), T& target)
{
using Bind = decltype(std::bind(setter, &target, std::placeholders::_1));
using Storer = decltype(storers::type_detector<Bind>(std::declval<V>()));
return new Value<Storer>(std::bind(setter, &target, std::placeholders::_1));
}
template <typename T, typename V> inline Base* reader(V T::* setter, T& target)
{
auto store = [setter,&target](V value) { target.*setter = value; };
using Storer = decltype(storers::type_detector<decltype(store)>(std::declval<V>()));
return new Value<Storer>(store);
}
template <typename T> inline Base* reader(std::string T::* setter, T& target)
{
auto store = [setter,&target](const char* str, size_t length) { (target.*setter).assign(str, length); };
using Storer = decltype(storers::type_detector<decltype(store)>(std::declval<std::string>()));
return new Value<Storer>(store);
}
// // for readers::Object<> derivatives, e.g. return readers::reader<JsonReaderChart>(&Ace::chart, target());
// template <template<typename> class Reader, typename Parent, typename Field> inline Base* reader(Field& (Parent::*accessor)(), Parent& parent)
// {
// using Bind = decltype(std::bind(std::declval<Field& (Parent::*&)()>(), std::declval<Parent*>()));
// return new Reader<Bind>(std::bind(accessor, &parent));
// }
// ----------------------------------------------------------------------
// reader makers
// ----------------------------------------------------------------------
namespace makers
{
template <typename Parent, typename Func>
class Setter : public Base<Parent>
{
public:
Setter(Func aF) : mF(aF) {}
virtual readers::Base* reader(Parent& parent) { return readers::reader(mF, parent); }
private:
Func mF;
};
template <typename Parent, typename Field, typename Func>
class Accessor : public Base<Parent>
{
public:
Accessor(Func aF, data<Field>& aData) : mF(aF), mData(aData) {}
virtual readers::Base* reader(Parent& parent)
{
return new DataRef<Field>(std::bind(mF, &parent)(), mData);
}
private:
Func mF;
data<Field>& mData;
};
template <typename Parent, typename Field>
class AccessorField : public Base<Parent>
{
public:
AccessorField(Field Parent::* aF, data<Field>& aData) : mF(aF), mData(aData) {}
virtual readers::Base* reader(Parent& parent)
{
return new DataRef<Field>(parent.*mF, mData);
}
private:
Field Parent::* mF;
data<Field>& mData;
};
template <typename Parent, typename Element, typename Func>
class ArrayOfObjectsAccessor : public Base<Parent>
{
public:
ArrayOfObjectsAccessor(Func aF, data<Element>& aData) : mF(aF), mData(aData) {}
virtual readers::Base* reader(Parent& parent)
{
return new ArrayOfObjects<Element>(std::bind(mF, &parent)(), mData);
}
private:
Func mF;
data<Element>& mData;
};
template <typename Parent, typename Element, typename Func, typename Storer>
class ArrayOfValuesAccessor : public Base<Parent>
{
public:
ArrayOfValuesAccessor(Func aF) : mF(aF) {}
virtual readers::Base* reader(Parent& parent)
{
return new ArrayOfValues<Element, Storer>(std::bind(mF, &parent)());
}
private:
Func mF;
};
template <typename Parent, typename Target, typename Func, typename Storer>
class ArrayOfArrayOfValuesTargetAccessor : public Base<Parent>
{
public:
ArrayOfArrayOfValuesTargetAccessor(Func aF) : mF(aF) {}
virtual readers::Base* reader(Parent& parent)
{
return new ArrayOfArrayOfValuesTarget<Target, Storer>(std::bind(mF, &parent)());
}
private:
Func mF;
};
template <typename Parent, typename Element, typename Func, typename Storer>
class ArrayOfArrayOfValuesAccessor : public Base<Parent>
{
public:
ArrayOfArrayOfValuesAccessor(Func aF) : mF(aF) {}
virtual readers::Base* reader(Parent& parent)
{
return new ArrayOfArrayOfValues<Element, Storer>(std::bind(mF, &parent)());
}
private:
Func mF;
};
template <typename Storer, typename Parent, typename Field>
class GenericAccessor : public Base<Parent>
{
public:
using Accessor = Field& (Parent::*)();
GenericAccessor(Accessor aAccessor) : mAccessor(aAccessor) {}
virtual readers::Base* reader(Parent& parent)
{
return new Storer(std::bind(mAccessor, &parent)());
}
private:
Accessor mAccessor;
};
template <typename Storer, typename Parent, typename Field>
class GenericAccessorField : public Base<Parent>
{
public:
using Accessor = Field Parent::*;
GenericAccessorField(Accessor aAccessor) : mAccessor(aAccessor) {}
virtual readers::Base* reader(Parent& parent)
{
return new Storer(parent.*mAccessor);
}
private:
Accessor mAccessor;
};
} // namespace makers
// ----------------------------------------------------------------------
} // namespace readers
// ----------------------------------------------------------------------
// Rapidjson event handler
// ----------------------------------------------------------------------
class EventHandler : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, EventHandler>
{
public:
// template <typename Target> EventHandler(Target& aTarget)
// {
// mHandler.emplace(json_reader(aTarget));
// }
template <typename Target> EventHandler(Target& aTarget, readers::data<Target>& aData)
{
mHandler.emplace(new readers::DataRef<Target>(aTarget, aData));
}
private:
#ifdef NO_EXCEPTIONS
template <typename... Args> bool handler(readers::Base* (readers::Base::*aHandler)(Args... args), Args... args)
{
auto new_handler = ((*mHandler.top()).*aHandler)(args...);
if (storers::_i::failure(new_handler)) {
return false;
}
else if (storers::_i::pop(new_handler)) {
if (mHandler.empty())
return false;
mHandler.pop();
}
else if (storers::_i::pop2(new_handler)) {
if (mHandler.empty())
return false;
mHandler.pop();
if (mHandler.empty())
return false;
mHandler.pop();
}
else if (new_handler) {
mHandler.emplace(new_handler);
}
return true;
}
#else
template <typename... Args> bool handler(readers::Base* (readers::Base::*aHandler)(Args... args), Args... args)
{
try {
auto new_handler = ((*mHandler.top()).*aHandler)(args...);
if (new_handler)
mHandler.emplace(new_handler);
}
catch (storers::_i::Pop&) {
if (mHandler.empty())
return false;
mHandler.pop();
}
catch (storers::_i::Pop2&) {
if (mHandler.empty())
return false;
mHandler.pop();
if (mHandler.empty())
return false;
mHandler.pop();
}
catch (storers::_i::Failure& err) {
if (*err.what())
std::cerr << "ERROR: " << err.what() << std::endl;
return false;
}
// catch (std::exception& err) {
// std::cerr << "ERROR: " << err.what() << std::endl;
// return false;
// }
return true;
}
#endif
public:
bool StartObject() { return handler(&readers::Base::StartObject); }
bool EndObject(rapidjson::SizeType /*memberCount*/) { return handler(&readers::Base::EndObject); }
bool StartArray() { return handler(&readers::Base::StartArray); }
bool EndArray(rapidjson::SizeType /*elementCount*/) { return handler(&readers::Base::EndArray); }
bool Key(const char* str, rapidjson::SizeType length, bool /*copy*/) { return handler(&readers::Base::Key, str, length); }
bool String(const char* str, rapidjson::SizeType length, bool /*copy*/) { return handler(&readers::Base::String, str, length); }
bool Int(int i) { return handler(&readers::Base::Int, i); }
bool Uint(unsigned u) { return handler(&readers::Base::Uint, u); }
bool Double(double d) { return handler(&readers::Base::Double, d); }
bool Bool(bool b) { return handler(&readers::Base::Bool, b); }
bool Null() { return handler(&readers::Base::Null); }
bool Int64(int64_t i) { return handler(&readers::Base::Int64, i); }
bool Uint64(uint64_t u) { return handler(&readers::Base::Uint64, u); }
private:
std::stack<std::unique_ptr<readers::Base>> mHandler;
}; // class EventHandler<>
// ======================================================================
// Exports
// ======================================================================
template <typename Parent> using data = readers::data<Parent>;
// Base class for custom Storers
using StorerBase = storers::Base;
// Field is a simple object set via setter: void Parent::setter(const Value& value)
template <typename Parent, typename ...Args> inline std::shared_ptr<readers::makers::Base<Parent>> field(void (Parent::*setter)(Args...))
{
return std::make_shared<readers::makers::Setter<Parent, decltype(setter)>>(setter);
}
// Field is a simple value set directly (e.g. double)
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field Parent::*setter)
{
return std::make_shared<readers::makers::Setter<Parent, decltype(setter)>>(setter);
}
// Field is a simple object set via setter: void ParentBase::setter(const Value& value)
// Parent is derived from ParentBase, setter declared in ParentBase (and accessible in Parent)
// must be specified as field<Parent>(&Parent::accessor)
template <typename Parent, typename ParentBase, typename ...Args> inline std::shared_ptr<readers::makers::Base<Parent>> field(void (ParentBase::*setter)(Args...))
{
using Setter = void (Parent::*)(Args...);
return std::make_shared<readers::makers::Setter<Parent, Setter>>(setter);
}
// Field is an Object accessible via: Field& Parent::accessor()
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field& (Parent::*accessor)(), data<Field>& aData)
{
return std::make_shared<readers::makers::Accessor<Parent, Field, decltype(accessor)>>(accessor, aData);
}
// Field is an Object accessible directly
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field Parent::*accessor, data<Field>& aData)
{
return std::make_shared<readers::makers::AccessorField<Parent, Field>>(accessor, aData);
}
// Array of Objects
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(std::vector<Field>& (Parent::*accessor)(), data<Field>& aData)
{
return std::make_shared<readers::makers::ArrayOfObjectsAccessor<Parent, Field, decltype(accessor)>>(accessor, aData);
}
// Array of values (via accessor function)
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(std::vector<Field>& (Parent::*accessor)())
{
using Storer = decltype(storers::type_detector<storers::ArrayElement<Field>>(std::declval<Field>()));
return std::make_shared<readers::makers::ArrayOfValuesAccessor<Parent, Field, decltype(accessor), Storer>>(accessor);
}
// Array of values (with inheritance)
// Access for Field of Parent, where
// Field is derived from std::vector<Element>
// Parent is derived from ParentBase, accessor declared in ParentBase (and accessible in Parent)
// must be specified as field<Element, Parent>(&Parent::accessor)
template <typename Element, typename Parent, typename ParentBase, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field& (ParentBase::*accessor)())
{
using Storer = decltype(storers::type_detector<storers::ArrayElement<Element>>(std::declval<Element>()));
return std::make_shared<readers::makers::ArrayOfValuesAccessor<Parent, Element, decltype(accessor), Storer>>(accessor);
}
// Array of array of values
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(std::vector<std::vector<Field>>& (Parent::*accessor)())
{
using Storer = decltype(storers::type_detector<storers::ArrayOfArrayElement<Field>>(std::declval<Field>()));
return std::make_shared<readers::makers::ArrayOfArrayOfValuesAccessor<Parent, Field, decltype(accessor), Storer>>(accessor);
}
// Array of array of double with inheritance
template <typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field& (Parent::*accessor)())
{
using Storer = decltype(storers::type_detector<storers::ArrayOfArrayElementTarget<Field>>(std::declval<double>()));
return std::make_shared<readers::makers::ArrayOfArrayOfValuesTargetAccessor<Parent, Field, decltype(accessor), Storer>>(accessor);
}
// Custom Storer (derived from storers::Base)
// must be specified as field<Storer, Parent, Field>(&Parent::accessor)
template <typename Storer, typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field& (Parent::*accessor)())
{
return std::make_shared<readers::makers::GenericAccessor<Storer, Parent, Field>>(accessor);
}
// Custom Storer (derived from storers::Base)
// must be specified as field<Storer, Parent, Field>(&Parent::field)
template <typename Storer, typename Parent, typename Field> inline std::shared_ptr<readers::makers::Base<Parent>> field(Field Parent::*accessor, typename std::enable_if<std::is_base_of<storers::Base, Storer>::value>::type* = nullptr)
{
return std::make_shared<readers::makers::GenericAccessorField<Storer, Parent, Field>>(accessor);
}
// ----------------------------------------------------------------------
template <typename Target> inline void import(std::string aSource, Target& aTarget, data<Target>& aData)
{
EventHandler handler{aTarget, aData};
rapidjson::Reader reader;
rapidjson::StringStream ss(aSource.c_str());
reader.Parse(ss, handler);
if (reader.HasParseError()) {
const auto message = "json_importer failed at " + std::to_string(reader.GetErrorOffset()) + ": "
+ GetParseError_En(reader.GetParseErrorCode()) + "\n"
+ aSource.substr(reader.GetErrorOffset(), 50);
throw std::runtime_error(message);
}
}
// ----------------------------------------------------------------------
} // namespace json_importer
// ----------------------------------------------------------------------
/// Local Variables:
/// eval: (if (fboundp 'eu-rename-buffer) (eu-rename-buffer))
/// End:
| 44.235646 | 237 | 0.499419 | acorg |
a2af88f95e82c5f6e52791053b6de7a610054d73 | 517 | hpp | C++ | src/code/Library/Synthesizer.hpp | 1iyiwei/texture | eaa78c00666060ca0a51c69920031b367c265e7d | [
"MIT"
] | 33 | 2017-04-13T18:32:42.000Z | 2021-12-21T07:53:59.000Z | src/code/Library/Synthesizer.hpp | 1iyiwei/texture | eaa78c00666060ca0a51c69920031b367c265e7d | [
"MIT"
] | 1 | 2021-09-24T07:21:03.000Z | 2021-09-29T23:39:41.000Z | src/code/Library/Synthesizer.hpp | 1iyiwei/texture | eaa78c00666060ca0a51c69920031b367c265e7d | [
"MIT"
] | 5 | 2017-04-12T17:46:03.000Z | 2021-03-31T00:50:12.000Z | /*
Synthesizer.hpp
the base class for all synthesizers
Li-Yi Wei
August 17, 2014
*/
#ifndef _SYNTHESIZER_HPP
#define _SYNTHESIZER_HPP
#include <set>
#include <string>
using namespace std;
#include "Texture.hpp"
#include "Neighborhood.hpp"
class Synthesizer
{
public:
virtual ~Synthesizer(void) = 0;
// synthesize a specific texel at target(position)
virtual string Synthesize(const Position & position, Texture & target) const;
protected:
typedef Range::DistType DistType;
};
#endif
| 15.205882 | 81 | 0.725338 | 1iyiwei |
a2af95919e3fffef582d72c7dacfbb8c82e25db2 | 3,237 | cpp | C++ | day/day_7/main.cpp | moki/aoc2020 | 6eaaaac14aa8a63aea8a6e462be4aa00b5ed385b | [
"BSD-3-Clause"
] | null | null | null | day/day_7/main.cpp | moki/aoc2020 | 6eaaaac14aa8a63aea8a6e462be4aa00b5ed385b | [
"BSD-3-Clause"
] | null | null | null | day/day_7/main.cpp | moki/aoc2020 | 6eaaaac14aa8a63aea8a6e462be4aa00b5ed385b | [
"BSD-3-Clause"
] | null | null | null | #include <algorithm>
#include <deque>
#include <fstream>
#include <iostream>
#include <unordered_map>
#include <vector>
typedef std::pair<std::string, size_t> bag;
constexpr char *delimeter = const_cast<char *>(" bag");
std::vector<bag>
parse_rule(std::string & line) {
size_t pos = 0;
bool first = true;
std::vector<bag> bags{};
while ((pos = line.find(delimeter)) != std::string::npos) {
auto rule = line.substr(0, pos);
line = line.substr(pos);
size_t amount = 1;
if (isdigit(rule[0])) {
auto pos_num_end = rule.find(" ");
amount = std::stoi(rule.substr(0, pos_num_end));
rule = rule.substr(pos_num_end + 1);
}
bags.push_back({rule, amount});
for (pos = 0; line[pos] && !isdigit(line[pos]); pos++)
;
line = line.substr(pos);
}
return bags;
}
int main(int argc, char **argv) {
std::fstream input(*++argv);
if (!input) {
exit(1);
}
std::vector<std::string> ass{};
auto sum = 0;
std::unordered_map<std::string, std::vector<bag>> paths{};
for (std::string line; std::getline(input, line);) {
auto bags = parse_rule(line);
auto it = bags.begin();
auto key = (*it).first;
bags.erase(it);
paths.insert({key, std::move(bags)});
}
auto lookup_bag = "shiny gold";
auto found = 0;
for (auto &path : paths) {
std::deque<bag> stack(path.second.begin(), path.second.end());
while (!stack.empty()) {
auto item = stack.back();
if (item.first == lookup_bag) {
found++;
break;
}
stack.pop_back();
auto lookup_path = paths.find(item.first);
if (lookup_path != paths.end()) {
stack.insert(stack.end(),
lookup_path->second.begin(),
lookup_path->second.end());
}
}
}
std::cout << "part 1: " << found << std::endl;
found = 0;
auto shiny_path = paths.find(lookup_bag);
std::deque<bag> stack(shiny_path->second.begin(),
shiny_path->second.end());
while (!stack.empty()) {
auto item = stack.back();
stack.pop_back();
auto path = paths.find(item.first);
if (path == paths.end())
break;
auto depth = item.second;
while (depth--) {
found++;
stack.insert(stack.end(), path->second.begin(),
path->second.end());
}
}
std::cout << "part 2: " << found << std::endl;
}
| 29.162162 | 78 | 0.416435 | moki |
a2b18846e34ac88590c98cf8ad3c6fb2236afccb | 232 | cpp | C++ | Source/JavascriptUMG/JavascriptMenuContext.cpp | keicoon/Unreal.js-core | 2d1ee2f909406cc778273590c1e2c2d3eb72c74a | [
"BSD-3-Clause"
] | 1 | 2021-12-30T17:12:48.000Z | 2021-12-30T17:12:48.000Z | Source/JavascriptUMG/JavascriptMenuContext.cpp | keicoon/Unreal.js-core | 2d1ee2f909406cc778273590c1e2c2d3eb72c74a | [
"BSD-3-Clause"
] | null | null | null | Source/JavascriptUMG/JavascriptMenuContext.cpp | keicoon/Unreal.js-core | 2d1ee2f909406cc778273590c1e2c2d3eb72c74a | [
"BSD-3-Clause"
] | null | null | null | #include "JavascriptMenuContext.h"
bool UJavascriptMenuContext::Public_CanExecute()
{
return OnCanExecute.IsBound() ? OnCanExecute.Execute() : true;
}
void UJavascriptMenuContext::Public_Execute()
{
OnExecute.ExecuteIfBound();
} | 21.090909 | 63 | 0.788793 | keicoon |
a2b7cee28bc2f4d79b96181d36bfaf70ea2d789f | 2,050 | hpp | C++ | contrib/autoboost/autoboost/preprocessor/seq/cat.hpp | CaseyCarter/autowiring | 48e95a71308318c8ffb7ed1348e034fd9110f70c | [
"Apache-2.0"
] | 87 | 2015-01-18T00:43:06.000Z | 2022-02-11T17:40:50.000Z | contrib/autoboost/autoboost/preprocessor/seq/cat.hpp | CaseyCarter/autowiring | 48e95a71308318c8ffb7ed1348e034fd9110f70c | [
"Apache-2.0"
] | 274 | 2015-01-03T04:50:49.000Z | 2021-03-08T09:01:09.000Z | contrib/autoboost/autoboost/preprocessor/seq/cat.hpp | CaseyCarter/autowiring | 48e95a71308318c8ffb7ed1348e034fd9110f70c | [
"Apache-2.0"
] | 15 | 2015-09-30T20:58:43.000Z | 2020-12-19T21:24:56.000Z | # /* **************************************************************************
# * *
# * (C) Copyright Paul Mensonides 2002.
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# * *
# ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef AUTOBOOST_PREPROCESSOR_SEQ_CAT_HPP
# define AUTOBOOST_PREPROCESSOR_SEQ_CAT_HPP
#
# include <autoboost/preprocessor/arithmetic/dec.hpp>
# include <autoboost/preprocessor/config/config.hpp>
# include <autoboost/preprocessor/control/if.hpp>
# include <autoboost/preprocessor/seq/fold_left.hpp>
# include <autoboost/preprocessor/seq/seq.hpp>
# include <autoboost/preprocessor/seq/size.hpp>
# include <autoboost/preprocessor/tuple/eat.hpp>
#
# /* AUTOBOOST_PP_SEQ_CAT */
#
# define AUTOBOOST_PP_SEQ_CAT(seq) \
AUTOBOOST_PP_IF( \
AUTOBOOST_PP_DEC(AUTOBOOST_PP_SEQ_SIZE(seq)), \
AUTOBOOST_PP_SEQ_CAT_I, \
AUTOBOOST_PP_SEQ_HEAD \
)(seq) \
/**/
# define AUTOBOOST_PP_SEQ_CAT_I(seq) AUTOBOOST_PP_SEQ_FOLD_LEFT(AUTOBOOST_PP_SEQ_CAT_O, AUTOBOOST_PP_SEQ_HEAD(seq), AUTOBOOST_PP_SEQ_TAIL(seq))
#
# define AUTOBOOST_PP_SEQ_CAT_O(s, st, elem) AUTOBOOST_PP_SEQ_CAT_O_I(st, elem)
# define AUTOBOOST_PP_SEQ_CAT_O_I(a, b) a ## b
#
# /* AUTOBOOST_PP_SEQ_CAT_S */
#
# define AUTOBOOST_PP_SEQ_CAT_S(s, seq) \
AUTOBOOST_PP_IF( \
AUTOBOOST_PP_DEC(AUTOBOOST_PP_SEQ_SIZE(seq)), \
AUTOBOOST_PP_SEQ_CAT_S_I_A, \
AUTOBOOST_PP_SEQ_CAT_S_I_B \
)(s, seq) \
/**/
# define AUTOBOOST_PP_SEQ_CAT_S_I_A(s, seq) AUTOBOOST_PP_SEQ_FOLD_LEFT_ ## s(AUTOBOOST_PP_SEQ_CAT_O, AUTOBOOST_PP_SEQ_HEAD(seq), AUTOBOOST_PP_SEQ_TAIL(seq))
# define AUTOBOOST_PP_SEQ_CAT_S_I_B(s, seq) AUTOBOOST_PP_SEQ_HEAD(seq)
#
# endif
| 41 | 156 | 0.628293 | CaseyCarter |
a2bdd69ffc8253373656cc6a59da5a138a5d3a58 | 3,233 | hpp | C++ | include/LIV/SDK/Unity/TEXTURE_COLOR_SPACE.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | include/LIV/SDK/Unity/TEXTURE_COLOR_SPACE.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | include/LIV/SDK/Unity/TEXTURE_COLOR_SPACE.hpp | RedBrumbler/virtuoso-codegen | e83f6f0f9b47bec4b6dd976b21edc1d46bf3cfe3 | [
"Unlicense"
] | null | null | null | // Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "beatsaber-hook/shared/utils/typedefs.h"
#include "beatsaber-hook/shared/utils/byref.hpp"
// Including type: System.Enum
#include "System/Enum.hpp"
// Completed includes
// Type namespace: LIV.SDK.Unity
namespace LIV::SDK::Unity {
// Forward declaring type: TEXTURE_COLOR_SPACE
struct TEXTURE_COLOR_SPACE;
}
#include "beatsaber-hook/shared/utils/il2cpp-type-check.hpp"
DEFINE_IL2CPP_ARG_TYPE(::LIV::SDK::Unity::TEXTURE_COLOR_SPACE, "LIV.SDK.Unity", "TEXTURE_COLOR_SPACE");
// Type namespace: LIV.SDK.Unity
namespace LIV::SDK::Unity {
// Size: 0x4
#pragma pack(push, 1)
// Autogenerated type: LIV.SDK.Unity.TEXTURE_COLOR_SPACE
// [TokenAttribute] Offset: FFFFFFFF
struct TEXTURE_COLOR_SPACE/*, public ::System::Enum*/ {
public:
public:
// public System.UInt32 value__
// Size: 0x4
// Offset: 0x0
uint value;
// Field size check
static_assert(sizeof(uint) == 0x4);
public:
// Creating value type constructor for type: TEXTURE_COLOR_SPACE
constexpr TEXTURE_COLOR_SPACE(uint value_ = {}) noexcept : value{value_} {}
// Creating interface conversion operator: operator ::System::Enum
operator ::System::Enum() noexcept {
return *reinterpret_cast<::System::Enum*>(this);
}
// Creating conversion operator: operator uint
constexpr operator uint() const noexcept {
return value;
}
// static field const value: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE UNDEFINED
static constexpr const uint UNDEFINED = 0u;
// Get static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE UNDEFINED
static ::LIV::SDK::Unity::TEXTURE_COLOR_SPACE _get_UNDEFINED();
// Set static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE UNDEFINED
static void _set_UNDEFINED(::LIV::SDK::Unity::TEXTURE_COLOR_SPACE value);
// static field const value: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE LINEAR
static constexpr const uint LINEAR = 1u;
// Get static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE LINEAR
static ::LIV::SDK::Unity::TEXTURE_COLOR_SPACE _get_LINEAR();
// Set static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE LINEAR
static void _set_LINEAR(::LIV::SDK::Unity::TEXTURE_COLOR_SPACE value);
// static field const value: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE SRGB
static constexpr const uint SRGB = 2u;
// Get static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE SRGB
static ::LIV::SDK::Unity::TEXTURE_COLOR_SPACE _get_SRGB();
// Set static field: static public LIV.SDK.Unity.TEXTURE_COLOR_SPACE SRGB
static void _set_SRGB(::LIV::SDK::Unity::TEXTURE_COLOR_SPACE value);
// Get instance field reference: public System.UInt32 value__
uint& dyn_value__();
}; // LIV.SDK.Unity.TEXTURE_COLOR_SPACE
#pragma pack(pop)
static check_size<sizeof(TEXTURE_COLOR_SPACE), 0 + sizeof(uint)> __LIV_SDK_Unity_TEXTURE_COLOR_SPACESizeCheck;
static_assert(sizeof(TEXTURE_COLOR_SPACE) == 0x4);
}
#include "beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
| 46.185714 | 112 | 0.72193 | RedBrumbler |
a2c13609a84ada4859b763fa0ef94b36240730aa | 553 | cpp | C++ | PharmacySystem/Purchase.cpp | ismaeelvaris/PharmacySystem | 940ab00dd3a26db467e34142eb2e4028a509b723 | [
"MIT"
] | 1 | 2018-04-25T18:05:07.000Z | 2018-04-25T18:05:07.000Z | PharmacySystem/Purchase.cpp | ismaeelvaris/PharmacySystem | 940ab00dd3a26db467e34142eb2e4028a509b723 | [
"MIT"
] | null | null | null | PharmacySystem/Purchase.cpp | ismaeelvaris/PharmacySystem | 940ab00dd3a26db467e34142eb2e4028a509b723 | [
"MIT"
] | null | null | null | #pragma once
#include <iostream>
#include <string>
using namespace std;
struct Purchase {
public:
Purchase(int prescriptionId, int itemId, int quantity, int salePrice) {
this->prescriptionId = prescriptionId;
this->itemId = itemId;
this->quantity = quantity;
this->salePrice = salePrice;
}
int getPrescriptionId() { return prescriptionId; }
int getItemId() { return itemId; }
int getQuantity() { return quantity; }
int getSalePrice() { return salePrice; }
private:
int prescriptionId;
int itemId;
int quantity;
int salePrice;
}; | 19.068966 | 72 | 0.723327 | ismaeelvaris |
a2c23e86007dcdf743c2c93d7fcda24247ae0568 | 3,785 | cpp | C++ | Code Chef/Iron, Magnet and Wall.cpp | akashmodak97/Competitive-Coding-and-Interview-Problems | a34fcb50378cf4bf4e5fd34e910eb68a1c05c066 | [
"MIT"
] | 51 | 2020-02-24T11:14:00.000Z | 2022-03-24T09:32:18.000Z | Code Chef/Iron, Magnet and Wall.cpp | akashmodak97/Competitive-Coding-and-Interview-Problems | a34fcb50378cf4bf4e5fd34e910eb68a1c05c066 | [
"MIT"
] | 3 | 2020-10-02T08:16:09.000Z | 2021-04-17T16:32:38.000Z | Code Chef/Iron, Magnet and Wall.cpp | akashmodak97/Competitive-Coding-and-Interview-Problems | a34fcb50378cf4bf4e5fd34e910eb68a1c05c066 | [
"MIT"
] | 18 | 2020-04-24T15:33:36.000Z | 2022-03-24T09:32:20.000Z | /* Code Chef */
/* Title - Iron, Magnet and Wall */
/* Created By - Akash Modak */
/* Date - 26/12/2020 */
// Chef loves to play with iron (Fe) and magnets (Ma). He took a row of N cells (numbered 1 through N) and placed some objects in some of these cells. You are given a string S with length N describing them; for each valid i, the i-th character of S is one of the following:
// 'I' if the i-th cell contains a piece of iron
// 'M' if the i-th cell contains a magnet
// '_' if the i-th cell is empty
// ':' if the i-th cell contains a conducting sheet
// 'X' if the i-th cell is blocked
// If there is a magnet in a cell i and iron in a cell j, the attraction power between these cells is Pi,j=K+1−|j−i|−Si,j, where Si,j is the number of cells containing sheets between cells i and j. This magnet can only attract this iron if Pi,j>0 and there are no blocked cells between the cells i and j.
// Chef wants to choose some magnets (possibly none) and to each of these magnets, assign a piece of iron which this magnet should attract. Each piece of iron may only be attracted by at most one magnet and only if the attraction power between them is positive and there are no blocked cells between them. Find the maximum number of magnets Chef can choose.
// Input
// The first line of the input contains a single integer T denoting the number of test cases. The description of T test cases follows.
// The first line of each test case contains two space-separated integers N and K.
// The second line contains a single string S with length N.
// Output
// For each test case, print a single line containing one integer ― the maximum number of magnets that can attract iron.
#include<bits/stdc++.h>
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define F first
#define S second
#define pb push_back
#define MP make_pair
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define FLSH fflush(stdout)
#define count_1(n) __builtin_popcountll(n)
#define max(x,y) (x>y)?x:y
#define min(x,y) (x<y)?x:y
#define mid(s,e) (s+(e-s)/2)
#define mini INT_MIN
#define maxi INT_MAX
const int MOD = 1000000007;
const int FMOD = 998244353;
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
int main() {
// your code goes here
fast;
int t;
cin>>t;
while(t--){
int n,k;
cin>>n>>k;
string s;
cin>>s;
int i,j=0,m=0,p=k+1,l,r,count=0;
queue<int> mag,iron;
for(i=0;i<n;i++){
if(s[i]=='M')
mag.push(i);
if(s[i]=='I')
iron.push(i);
if(s[i]=='X' || i==n-1){
int l,r,sheet=0,q;
while(!mag.empty() && !iron.empty()){
sheet=0;
l = min(mag.front(),iron.front());
r = max(mag.front(),iron.front());
for(q=l;q<=r;q++){
if(s[q]==':')
sheet++;
}
if((p-abs(l-r)-sheet)>0){
count++;
mag.pop();
iron.pop();
}
else if(mag.front()<iron.front()){
mag.pop();
}
else{
iron.pop();
}
}
while(!mag.empty())
mag.pop();
while(!iron.empty())
iron.pop();
}
}
cout<<count<<"\n";
}
return 0;
}
| 38.622449 | 358 | 0.529458 | akashmodak97 |
a2c3f83e25469243923c5bf9fc73de2f0899c3f3 | 2,494 | hpp | C++ | openstudiocore/src/model/ModelObjectList.hpp | bobzabcik/OpenStudio | 858321dc0ad8d572de15858d2ae487b029a8d847 | [
"blessing"
] | null | null | null | openstudiocore/src/model/ModelObjectList.hpp | bobzabcik/OpenStudio | 858321dc0ad8d572de15858d2ae487b029a8d847 | [
"blessing"
] | null | null | null | openstudiocore/src/model/ModelObjectList.hpp | bobzabcik/OpenStudio | 858321dc0ad8d572de15858d2ae487b029a8d847 | [
"blessing"
] | null | null | null | /**********************************************************************
* Copyright (c) 2008-2013, Alliance for Sustainable Energy.
* All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
**********************************************************************/
#ifndef MODEL_MODELOBJECTLIST_HPP
#define MODEL_MODELOBJECTLIST_HPP
#include <model/ModelAPI.hpp>
#include <model/ModelObject.hpp>
namespace openstudio {
namespace model {
namespace detail {
class ModelObjectList_Impl;
} // detail
/** ModelObjectList is a ModelObject that wraps the OpenStudio IDD object 'OS:ModelObjectList'. */
class MODEL_API ModelObjectList : public ModelObject {
public:
/** @name Constructors and Destructors */
//@{
explicit ModelObjectList(const Model& model);
virtual ~ModelObjectList() {}
//@}
static IddObjectType iddObjectType();
std::vector<IdfObject> remove();
ModelObject clone(Model model) const;
bool addModelObject(const ModelObject & modelObject );
void removeModelObject(const ModelObject & modelObject );
void removeAllModelObjects();
std::vector< ModelObject > modelObjects() const;
protected:
/// @cond
typedef detail::ModelObjectList_Impl ImplType;
explicit ModelObjectList(boost::shared_ptr<detail::ModelObjectList_Impl> impl);
friend class detail::ModelObjectList_Impl;
friend class Model;
friend class IdfObject;
friend class openstudio::detail::IdfObject_Impl;
/// @endcond
private:
REGISTER_LOGGER("openstudio.model.ModelObjectList");
};
/** \relates ModelObjectList*/
typedef boost::optional<ModelObjectList> OptionalModelObjectList;
/** \relates ModelObjectList*/
typedef std::vector<ModelObjectList> ModelObjectListVector;
} // model
} // openstudio
#endif // MODEL_MODELOBJECTLIST_HPP
| 28.666667 | 98 | 0.709703 | bobzabcik |
a2c447a7acd7c74cdf2cf2d09f451b5b5c43a410 | 32,824 | cpp | C++ | DeviceCode/pal/PKCS11/Tokens/OpenSSL/OpenSSL_PKCS11_objects.cpp | PervasiveDigital/netmf-interpreter | 03d84fe76e0b666ebec62d17d69c55c45940bc40 | [
"Apache-2.0"
] | 529 | 2015-03-10T00:17:45.000Z | 2022-03-17T02:21:19.000Z | DeviceCode/pal/PKCS11/Tokens/OpenSSL/OpenSSL_PKCS11_objects.cpp | PervasiveDigital/netmf-interpreter | 03d84fe76e0b666ebec62d17d69c55c45940bc40 | [
"Apache-2.0"
] | 495 | 2015-03-10T22:02:46.000Z | 2019-05-16T13:05:00.000Z | DeviceCode/pal/PKCS11/Tokens/OpenSSL/OpenSSL_PKCS11_objects.cpp | PervasiveDigital/netmf-interpreter | 03d84fe76e0b666ebec62d17d69c55c45940bc40 | [
"Apache-2.0"
] | 332 | 2015-03-10T08:04:36.000Z | 2022-03-29T04:18:36.000Z | #include "OpenSSL_pkcs11.h"
#include <PEM\pem.h>
#include <PKCS12\pkcs12.h>
#include <TinyCLR\ssl_functions.h>
OBJECT_DATA PKCS11_Objects_OpenSSL::s_Objects[];
void PKCS11_Objects_OpenSSL::IntitializeObjects()
{
memset(PKCS11_Objects_OpenSSL::s_Objects, 0, sizeof(PKCS11_Objects_OpenSSL::s_Objects));
}
int PKCS11_Objects_OpenSSL::FindEmptyObjectHandle()
{
int index;
for(index=0; index<ARRAYSIZE(s_Objects); index++)
{
if(s_Objects[index].Data == NULL) break;
}
return index < ARRAYSIZE(s_Objects) ? index : -1;
}
OBJECT_DATA* PKCS11_Objects_OpenSSL::GetObjectFromHandle(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject)
{
OBJECT_DATA* retVal;
if((int)hObject < 0 || hObject >= ARRAYSIZE(s_Objects))
{
return NULL;
}
retVal = &s_Objects[(int)hObject];
return (retVal->Data == NULL) ? NULL : retVal;
}
BOOL PKCS11_Objects_OpenSSL::FreeObject(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject)
{
OBJECT_DATA* retVal;
if((int)hObject < 0 || hObject >= ARRAYSIZE(s_Objects))
{
return FALSE;
}
retVal = &s_Objects[(int)hObject];
if(retVal->Data == NULL) return FALSE;
TINYCLR_SSL_FREE(retVal->Data);
retVal->Data = NULL;
retVal->RefCount = 0;
return TRUE;
}
CK_OBJECT_HANDLE PKCS11_Objects_OpenSSL::AllocObject(Cryptoki_Session_Context* pSessionCtx, ObjectType type, size_t size, OBJECT_DATA** ppData)
{
int idx = FindEmptyObjectHandle();
*ppData = NULL;
if(idx == -1) return idx;
*ppData = &s_Objects[idx];
(*ppData)->Type = type;
(*ppData)->Data = TINYCLR_SSL_MALLOC(size);
(*ppData)->RefCount = 1;
if((*ppData)->Data == NULL) return CK_OBJECT_HANDLE_INVALID;
TINYCLR_SSL_MEMSET((*ppData)->Data, 0, size);
return (CK_OBJECT_HANDLE)idx;
}
CK_RV PKCS11_Objects_OpenSSL::LoadX509Cert(Cryptoki_Session_Context* pSessionCtx, X509* x, OBJECT_DATA** ppObject, EVP_PKEY* privateKey, CK_OBJECT_HANDLE_PTR phObject)
{
CERT_DATA* pCert;
EVP_PKEY* pubKey = X509_get_pubkey(x);
UINT32 keyType = CKK_VENDOR_DEFINED;
if(phObject == NULL) return CKR_ARGUMENTS_BAD;
*phObject = AllocObject(pSessionCtx, CertificateType, sizeof(CERT_DATA), ppObject);
if(*phObject == CK_OBJECT_HANDLE_INVALID)
{
return CKR_FUNCTION_FAILED;
}
if(pubKey != NULL)
{
switch(pubKey->type)
{
case EVP_PKEY_RSA:
case EVP_PKEY_RSA2:
keyType = CKK_RSA;
break;
case EVP_PKEY_DSA:
case EVP_PKEY_DSA1:
case EVP_PKEY_DSA2:
case EVP_PKEY_DSA3:
case EVP_PKEY_DSA4:
keyType = CKK_DSA;
break;
case EVP_PKEY_DH:
keyType = CKK_DH;
break;
case EVP_PKEY_EC:
keyType = CKK_DH;
break;
}
}
pCert = (CERT_DATA*)(*ppObject)->Data;
pCert->cert = x;
pCert->privKeyData.key = privateKey;
if(privateKey != NULL)
{
pCert->privKeyData.attrib = Private;
pCert->privKeyData.type = keyType;
pCert->privKeyData.size = EVP_PKEY_bits(privateKey);
}
pCert->pubKeyData.key = pubKey;
pCert->pubKeyData.attrib = Public;
pCert->pubKeyData.type = keyType;
pCert->pubKeyData.size = EVP_PKEY_bits(pubKey);
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::CreateObject(Cryptoki_Session_Context* pSessionCtx, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject)
{
UINT32 attribIndex = 0;
if(pTemplate[attribIndex].type == CKA_CLASS && pTemplate[attribIndex].ulValueLen == sizeof(CK_OBJECT_CLASS))
{
CK_OBJECT_CLASS cls = SwapEndianIfBEc32(*(CK_OBJECT_CLASS*)pTemplate[attribIndex].pValue);
CHAR pwd[64];
int len;
switch(cls)
{
case CKO_CERTIFICATE:
for(++attribIndex; attribIndex < ulCount; attribIndex++)
{
switch(pTemplate[attribIndex].type)
{
case CKA_PASSWORD:
len = pTemplate[attribIndex].ulValueLen;
if(len >= ARRAYSIZE(pwd))
{
len = ARRAYSIZE(pwd) - 1;
}
TINYCLR_SSL_MEMCPY(pwd, pTemplate[attribIndex].pValue, len);
pwd[len] = 0;
break;
case CKA_VALUE:
{
OBJECT_DATA* pObject = NULL;
EVP_PKEY* privateKey = NULL;
X509 *x = ssl_parse_certificate(pTemplate[attribIndex].pValue, pTemplate[attribIndex].ulValueLen, pwd, &privateKey);
if (x == NULL)
{
TINYCLR_SSL_PRINTF("Unable to load certificate\n");
return CKR_FUNCTION_FAILED;
}
else
{
CK_RV retVal = LoadX509Cert(pSessionCtx, x, &pObject, privateKey, phObject);
if(retVal != CKR_OK) X509_free(x);
return retVal;
}
}
}
}
break;
}
}
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV PKCS11_Objects_OpenSSL::CopyObject(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phNewObject)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
CK_RV PKCS11_Objects_OpenSSL::DestroyObject(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject)
{
OBJECT_DATA* pData = GetObjectFromHandle(pSessionCtx, hObject);
if(pData == NULL) return CKR_OBJECT_HANDLE_INVALID;
if(--pData->RefCount <= 0)
{
if(pData->Type == KeyType)
{
PKCS11_Keys_OpenSSL::DeleteKey(pSessionCtx, (KEY_DATA *)pData->Data);
}
else if(pData->Type == CertificateType)
{
CERT_DATA* pCert = (CERT_DATA*)pData->Data;
X509_free(pCert->cert);
}
return FreeObject(pSessionCtx, hObject) == NULL ? CKR_OBJECT_HANDLE_INVALID : CKR_OK;
}
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::GetObjectSize(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
//MS: copied decoding algo from get_ASN1_UTCTIME of asn1_openssl.lib
//MS: populate DATE_TIME_INFO struct with year,month, day,hour,minute,second,etc
static int ssl_get_ASN1_UTCTIME(const ASN1_UTCTIME *tm, DATE_TIME_INFO *dti)
{
const char *v;
int gmt=0;
int i;
int y=0,M=0,d=0,h=0,m=0,s=0;
memset(dti, 0, sizeof(*dti));
i=tm->length;
v=(const char *)tm->data;
if (i < 10) { goto err; }
if (v[i-1] == 'Z') gmt=1;
for (i=0; i<10; i++)
if ((v[i] > '9') || (v[i] < '0')) { goto err; }
y= (v[0]-'0')*10+(v[1]-'0');
if (y < 50) y+=100;
M= (v[2]-'0')*10+(v[3]-'0');
if ((M > 12) || (M < 1)) { goto err; }
d= (v[4]-'0')*10+(v[5]-'0');
h= (v[6]-'0')*10+(v[7]-'0');
m= (v[8]-'0')*10+(v[9]-'0');
if (tm->length >=12 &&
(v[10] >= '0') && (v[10] <= '9') &&
(v[11] >= '0') && (v[11] <= '9'))
s= (v[10]-'0')*10+(v[11]-'0');
dti->year = SwapEndianIfBEc32(y+1900);
dti->month = SwapEndianIfBEc32(M);
dti->day = SwapEndianIfBEc32(d);
dti->hour = SwapEndianIfBEc32(h);
dti->minute = SwapEndianIfBEc32(m);
dti->second = SwapEndianIfBEc32(s);
dti->dlsTime = 0; //TODO:HOW to find
dti->tzOffset = SwapEndianIfBEc32(gmt); //TODO:How to find
return(1);
err:
TINYCLR_SSL_PRINTF("Bad time value\r\n");
return(0);
}
CK_RV PKCS11_Objects_OpenSSL::GetAttributeValue(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
OBJECT_DATA* pObj = PKCS11_Objects_OpenSSL::GetObjectFromHandle(pSessionCtx, hObject);
if(pObj == NULL) return CKR_OBJECT_HANDLE_INVALID;
if(pObj->Type == CertificateType)
{
CERT_DATA* pCertData = (CERT_DATA*)pObj->Data;
X509* pCert = pCertData->cert;
INT32 valLen = 0;
for(int i=0; i<(int)ulCount; i++)
{
switch(pTemplate[i].type)
{
case CKA_CLASS:
*(INT32*)pTemplate[i].pValue = SwapEndianIfBEc32(CKO_CERTIFICATE);
break;
case CKA_PRIVATE:
*(INT32*)pTemplate[i].pValue = SwapEndianIfBEc32(pCertData->privKeyData.key == NULL ? 0 : 1);
valLen = sizeof(INT32);
break;
case CKA_VALUE_BITS:
{
*(INT32*)pTemplate[i].pValue = SwapEndianIfBEc32(pCertData->pubKeyData.size);
valLen = sizeof(INT32);
}
break;
case CKA_KEY_TYPE:
{
*(UINT32*)pTemplate[i].pValue = SwapEndianIfBEc32(pCertData->pubKeyData.type);
valLen = sizeof(UINT32);
}
break;
case CKA_ISSUER:
{
char* name=X509_NAME_oneline(X509_get_issuer_name(pCert),NULL,0);
valLen = TINYCLR_SSL_STRLEN(name) + 1;
if(valLen > pTemplate[i].ulValueLen) valLen = pTemplate[i].ulValueLen;
hal_strcpy_s((char*)pTemplate[i].pValue, valLen, name);
OPENSSL_free(name);
}
break;
case CKA_SUBJECT:
{
char* subject=X509_NAME_oneline(X509_get_subject_name(pCert),NULL,0);
valLen = TINYCLR_SSL_STRLEN(subject) + 1;
if(valLen > pTemplate[i].ulValueLen) valLen = pTemplate[i].ulValueLen;
hal_strcpy_s((char*)pTemplate[i].pValue, valLen, subject);
OPENSSL_free(subject);
}
break;
case CKA_SERIAL_NUMBER:
{
ASN1_INTEGER* asn = X509_get_serialNumber(pCert);
valLen = asn->length;
if(valLen > pTemplate[i].ulValueLen) valLen = pTemplate[i].ulValueLen;
TINYCLR_SSL_MEMCPY(pTemplate[i].pValue, asn->data, valLen);
}
break;
case CKA_MECHANISM_TYPE:
if(pCert->sig_alg != NULL)
{
int signature_nid;
CK_MECHANISM_TYPE type = CKM_VENDOR_DEFINED;
signature_nid = OBJ_obj2nid(pCert->sig_alg->algorithm);
switch(signature_nid)
{
case NID_sha1WithRSA:
case NID_sha1WithRSAEncryption:
//szNid = "1.2.840.113549.1.1.5";
type = CKM_SHA1_RSA_PKCS;
break;
case NID_md5WithRSA:
case NID_md5WithRSAEncryption:
//szNid = "1.2.840.113549.1.1.4";
type = CKM_MD5_RSA_PKCS;
break;
case NID_sha256WithRSAEncryption:
//szNid = "1.2.840.113549.1.1.11";
type = CKM_SHA256_RSA_PKCS;
break;
case NID_sha384WithRSAEncryption:
//szNid = "1.2.840.113549.1.1.12";
type = CKM_SHA384_RSA_PKCS;
break;
case NID_sha512WithRSAEncryption:
//szNid = "1.2.840.113549.1.1.13";
type = CKM_SHA512_RSA_PKCS;
break;
}
valLen = sizeof(CK_MECHANISM_TYPE);
*(CK_MECHANISM_TYPE*)pTemplate[i].pValue = SwapEndianIfBEc32(type);
}
break;
case CKA_START_DATE:
{
DATE_TIME_INFO dti;
ssl_get_ASN1_UTCTIME(X509_get_notBefore(pCert), &dti);
valLen = (INT32)pTemplate[i].ulValueLen;
if(valLen > sizeof(dti)) valLen = sizeof(dti);
TINYCLR_SSL_MEMCPY(pTemplate[i].pValue, &dti, valLen);
}
break;
case CKA_END_DATE:
{
DATE_TIME_INFO dti;
ssl_get_ASN1_UTCTIME(X509_get_notAfter(pCert), &dti);
valLen = pTemplate[i].ulValueLen;
if(valLen > sizeof(dti)) valLen = sizeof(dti);
TINYCLR_SSL_MEMCPY(pTemplate[i].pValue, &dti, valLen);
}
break;
case CKA_VALUE:
{
UINT8* pData = (UINT8*)pTemplate[i].pValue;
UINT8* pTmp = pData;
valLen = i2d_X509(pCert, NULL);
if(valLen > pTemplate[i].ulValueLen) return CKR_DEVICE_MEMORY;
valLen = i2d_X509(pCert, &pTmp);
if(valLen < 0) return CKR_FUNCTION_FAILED;
}
break;
case CKA_VALUE_LEN:
*(UINT32*)pTemplate[i].pValue = SwapEndianIfBEc32(valLen);
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
}
}
else if(pObj->Type == KeyType)
{
KEY_DATA* pKey = (KEY_DATA*)pObj->Data;
int valLen = 0;
bool isPrivate = false;
for(int i=0; i<(int)ulCount; i++)
{
switch(pTemplate[i].type)
{
case CKA_CLASS:
*(INT32*)pTemplate[i].pValue = SwapEndianIfBEc32((0 != (pKey->attrib & Private) ? CKO_PRIVATE_KEY : 0 != (pKey->attrib & Public) ? CKO_PUBLIC_KEY : CKO_SECRET_KEY));
break;
case CKA_MODULUS:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->n, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_EXPONENT_1:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->dmp1, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_EXPONENT_2:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->dmq1, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_COEFFICIENT:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->iqmp, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PRIME_1:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->p, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PRIME_2:
if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->q, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PRIVATE_EXPONENT:
if(pKey->type == CKK_DSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.dsa->priv_key, (UINT8*)pTemplate[i].pValue);
}
else if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->d, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PUBLIC_EXPONENT:
if(pKey->type == CKK_DSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.dsa->pub_key, (UINT8*)pTemplate[i].pValue);
}
else if(pKey->type == CKK_EC)
{
UINT8 pTmp[66*2+1];
EC_KEY* pEC = ((EVP_PKEY*)pKey->key)->pkey.ec;
const EC_POINT* point = EC_KEY_get0_public_key(pEC);
valLen = EC_POINT_point2oct(EC_KEY_get0_group(pEC), point, POINT_CONVERSION_UNCOMPRESSED, (UINT8*)pTmp, ARRAYSIZE(pTmp), NULL);
if(valLen == 0) return CKR_FUNCTION_FAILED;
memmove(pTemplate[i].pValue, &pTmp[1], valLen-1); // remove POINT_CONVERSION_UNCOMPRESSED header byte
}
else if(pKey->type == CKK_RSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.rsa->e, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PRIME:
if(pKey->type == CKK_DSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.dsa->p, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_SUBPRIME:
if(pKey->type == CKK_DSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.dsa->q, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_BASE:
if(pKey->type == CKK_DSA)
{
EVP_PKEY* pRealKey = (EVP_PKEY*)pKey->key;
valLen = BN_bn2bin(pRealKey->pkey.dsa->g, (UINT8*)pTemplate[i].pValue);
}
break;
case CKA_PRIVATE:
isPrivate = 0 != *(INT32*)pTemplate[i].pValue;
break;
case CKA_KEY_TYPE:
*(INT32*)pTemplate[i].pValue = SwapEndianIfBEc32(pKey->type);
break;
case CKA_VALUE_BITS:
*(UINT32*)pTemplate[i].pValue = SwapEndianIfBEc32(pKey->size);
break;
case CKA_VALUE:
switch(pKey->type)
{
case CKK_AES:
case CKK_GENERIC_SECRET:
{
// TODO: Add permissions to export key
int len = (pKey->size + 7) / 8;
if(len > (INT32)pTemplate[i].ulValueLen) len = (int)pTemplate[i].ulValueLen;
TINYCLR_SSL_MEMCPY(pTemplate[i].pValue, pKey->key, len);
valLen = len;
}
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
break;
case CKA_VALUE_LEN:
switch(pKey->type)
{
case CKK_EC:
*(UINT32*)pTemplate[i].pValue = SwapEndianIfBEc32(valLen);
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
}
}
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::SetAttributeValue(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
OBJECT_DATA* pObj = PKCS11_Objects_OpenSSL::GetObjectFromHandle(pSessionCtx, hObject);
if(pObj == NULL) return CKR_OBJECT_HANDLE_INVALID;
if(pObj->Type == CertificateType)
{
CERT_DATA* pCertData = (CERT_DATA*)pObj->Data;
X509* pCert = pCertData->cert;
CHAR group[20] = {0};
CHAR fileName[20] = {0};
INT32 len = 0;
BOOL fSave = FALSE;
BOOL fDelete = FALSE;
for(int i=0; i<(int)ulCount; i++)
{
switch(pTemplate[i].type)
{
case CKA_PERSIST:
fSave = SwapEndianIfBEc32(*(INT32*)pTemplate[i].pValue) != 0;
fDelete = !fSave;
break;
case CKA_LABEL:
len = pTemplate[i].ulValueLen;
if(len >= ARRAYSIZE(group))
{
len = ARRAYSIZE(group) - 1;
}
TINYCLR_SSL_MEMCPY(group, pTemplate[i].pValue, len);
group[len] = 0;
break;
case CKA_OBJECT_ID:
len = pTemplate[i].ulValueLen;
if(len >= ARRAYSIZE(fileName))
{
len = ARRAYSIZE(fileName) - 1;
}
TINYCLR_SSL_MEMCPY(fileName, pTemplate[i].pValue, len);
fileName[len] = 0;
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
}
if(fDelete)
{
hal_strcpy_s(fileName, ARRAYSIZE(pObj->FileName), pObj->FileName);
pObj->GroupName[0] = 0;
if(g_OpenSSL_Token.Storage != NULL && g_OpenSSL_Token.Storage->Delete != NULL)
{
if(!g_OpenSSL_Token.Storage->Delete(fileName, group)) return CKR_FUNCTION_FAILED;
}
else
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
}
else if(fSave)
{
hal_strcpy_s(pObj->GroupName, ARRAYSIZE(pObj->GroupName), group );
hal_strcpy_s(pObj->FileName , ARRAYSIZE(pObj->FileName ), fileName);
if(g_OpenSSL_Token.Storage != NULL && g_OpenSSL_Token.Storage->Create != NULL)
{
BOOL res;
UINT8* pData, *pTmp;
INT32 len = i2d_X509( pCert, NULL );
if(len <= 0) return CKR_FUNCTION_FAILED;
pData = (UINT8*)TINYCLR_SSL_MALLOC(len);
if(pData == NULL) return CKR_DEVICE_MEMORY;
pTmp = pData;
i2d_X509(pCert, &pTmp);
// TODO: Save private key as well
res = g_OpenSSL_Token.Storage->Create( fileName, group, CertificateType, pData, len );
TINYCLR_SSL_FREE(pData);
if(!res) return CKR_FUNCTION_FAILED;
}
else
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
}
else
{
return CKR_ATTRIBUTE_TYPE_INVALID;
}
}
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::FindObjectsInit(Cryptoki_Session_Context* pSessionCtx, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
FIND_OBJECT_DATA *pData;
INT32 i = 0, len;
if(pSessionCtx->FindObjectsCtx != NULL)
{
return CKR_FUNCTION_NOT_PARALLEL;
}
pData = (FIND_OBJECT_DATA*)TINYCLR_SSL_MALLOC(sizeof(FIND_OBJECT_DATA));
if(pData == NULL) return CKR_DEVICE_MEMORY;
pSessionCtx->FindObjectsCtx = pData;
pData->FileName[0] = 0;
pData->GroupName[0] = 0;
while(i < ulCount)
{
switch(pTemplate[i].type)
{
case CKA_CLASS:
switch(SwapEndianIfBEc32(*(INT32*)pTemplate[i].pValue))
{
case CKO_CERTIFICATE:
pData->ObjectType = CertificateType;
break;
case CKO_PUBLIC_KEY:
case CKO_SECRET_KEY:
case CKO_PRIVATE_KEY:
pData->ObjectType = KeyType;
break;
default:
pData->ObjectType = DataType;
break;
}
break;
case CKA_LABEL:
len = pTemplate[i].ulValueLen;
if(len >= ARRAYSIZE(pData->GroupName))
{
len = ARRAYSIZE(pData->GroupName) - 1;
}
TINYCLR_SSL_MEMCPY( pData->GroupName, pTemplate[i].pValue, len );
pData->GroupName[len] = 0;
break;
case CKA_OBJECT_ID:
len = pTemplate[i].ulValueLen;
if(len >= ARRAYSIZE(pData->FileName))
{
len = ARRAYSIZE(pData->FileName) - 1;
}
TINYCLR_SSL_MEMCPY( pData->FileName, pTemplate[i].pValue, len );
pData->FileName[len] = 0;
break;
default:
return CKR_ATTRIBUTE_TYPE_INVALID;
}
i++;
}
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::FindObjects(Cryptoki_Session_Context* pSessionCtx, CK_OBJECT_HANDLE_PTR phObjects, CK_ULONG ulMaxCount, CK_ULONG_PTR pulObjectCount)
{
FIND_OBJECT_DATA *pData = (FIND_OBJECT_DATA*)pSessionCtx->FindObjectsCtx;
UINT32 cntObj = 0;
*pulObjectCount = 0;
if(pData == NULL) return CKR_FUNCTION_FAILED;
if(ulMaxCount == 0) return CKR_ARGUMENTS_BAD;
{
FileEnumCtx ctx;
CHAR fileName[20];
if(g_OpenSSL_Token.Storage == NULL || g_OpenSSL_Token.Storage->GetFileEnum == NULL)
{
return CKR_FUNCTION_NOT_SUPPORTED;
}
if(!g_OpenSSL_Token.Storage->GetFileEnum(pData->GroupName, pData->ObjectType, ctx)) return CKR_FUNCTION_FAILED;
while(g_OpenSSL_Token.Storage->GetNextFile(ctx, fileName, ARRAYSIZE(fileName)))
{
UINT32 dataLen = 0;
if(g_OpenSSL_Token.Storage->Read(fileName, pData->GroupName, pData->ObjectType, NULL, dataLen))
{
UINT8* pObj = (UINT8*)TINYCLR_SSL_MALLOC(dataLen);
if(pObj)
{
g_OpenSSL_Token.Storage->Read(fileName, pData->GroupName, pData->ObjectType, pObj, dataLen);
switch(pData->ObjectType)
{
case CertificateType:
{
OBJECT_DATA *pObject = NULL;
const UINT8* pTmp = pObj;
CK_OBJECT_HANDLE hObjTmp, *pObjHandle;
X509* x509 = d2i_X509(NULL, &pTmp, dataLen);
if(x509 == NULL)
{
TINYCLR_SSL_FREE(pObj);
return CKR_FUNCTION_FAILED;
}
if(phObjects == NULL)
{
pObjHandle = &hObjTmp;
}
else
{
pObjHandle = &phObjects[cntObj];
}
if(CKR_OK != LoadX509Cert(pSessionCtx, x509, &pObject, NULL, pObjHandle))
{
X509_free(x509);
TINYCLR_SSL_FREE(pObj);
//return CKR_FUNCTION_FAILED;
g_OpenSSL_Token.Storage->Delete( fileName, pData->GroupName );
continue;
}
hal_strcpy_s(pObject->GroupName, ARRAYSIZE(pObject->GroupName), pData->GroupName);
hal_strcpy_s(pObject->FileName , ARRAYSIZE(pObject->FileName ), fileName );
cntObj++;
TINYCLR_SSL_FREE(pObj);
if(cntObj >= ulMaxCount)
{
*pulObjectCount = cntObj;
return CKR_OK;
}
}
break;
case KeyType:
{
// TODO:
TINYCLR_SSL_FREE(pObj);
}
break;
default:
// TODO:
TINYCLR_SSL_FREE(pObj);
break;
}
}
}
}
}
*pulObjectCount = cntObj;
return CKR_OK;
}
CK_RV PKCS11_Objects_OpenSSL::FindObjectsFinal(Cryptoki_Session_Context* pSessionCtx)
{
if(pSessionCtx->FindObjectsCtx != NULL)
{
TINYCLR_SSL_FREE(pSessionCtx->FindObjectsCtx);
pSessionCtx->FindObjectsCtx = NULL;
}
return CKR_OK;
}
| 34.085151 | 186 | 0.443486 | PervasiveDigital |
a2c9a23508b58bc55999787bef84c073718a6d0a | 404 | cpp | C++ | src/datatype.cpp | BergerZvika/smt-switch | c65dc8529c81b04443807147da2c5cebdccf216d | [
"BSD-3-Clause"
] | 49 | 2018-02-20T12:47:28.000Z | 2021-08-14T17:06:19.000Z | src/datatype.cpp | BergerZvika/smt-switch | c65dc8529c81b04443807147da2c5cebdccf216d | [
"BSD-3-Clause"
] | 117 | 2017-06-30T18:26:02.000Z | 2021-08-17T19:50:18.000Z | src/datatype.cpp | BergerZvika/smt-switch | c65dc8529c81b04443807147da2c5cebdccf216d | [
"BSD-3-Clause"
] | 21 | 2019-10-10T22:22:03.000Z | 2021-07-22T14:15:10.000Z | #include "datatype.h"
namespace smt {
// Overloaded operators simply call the constructors' comparison functions
bool operator==(const DatatypeConstructorDecl & d1,
const DatatypeConstructorDecl & d2)
{
return d1->compare(d2);
}
bool operator!=(const DatatypeConstructorDecl & d1,
const DatatypeConstructorDecl & d2)
{
return !d1->compare(d2);
}
} // namespace smt
| 23.764706 | 74 | 0.695545 | BergerZvika |