void TestFText()
{
FText t1 = FText::AsNumber(1.0f);
Debug(t1);
t1 = FText::AsPercent(0.1f);
Debug(t1);
t1 = FText::AsCurrency(1.0f);
Debug(t1);
t1 = FText::AsDate(FDateTime(2016, 8, 22, 10, 34, 1, 1));
Debug(t1);
t1 = FText::AsTime(FDateTime(2016, 8, 22, 10, 34, 1, 1));
Debug(t1);
t1 = FText::AsDateTime(FDateTime(2016, 8, 22, 10, 34, 1, 1));
Debug(t1);
// format
t1 = FText::Format(FText::FromString(TEXT("Health:{0}/{1}")), FText::AsNumber(50), FText::AsNumber(100));
Debug(t1);
FFormatNamedArguments arguments;
arguments.Add(TEXT("key1"), FText::AsPercent(0.1f));
t1 = FText::Format(FText::FromString(TEXT("percent={key1}/{key2}")), arguments);
Debug(t1);
}
UUTT61_DebugReplicateData::UUTT61_DebugReplicateData(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
, Replicator(NULL)
, ExploitFailLog(TEXT("Blank exploit fail log message"))
{
UnitTestName = TEXT("ReplicateDataCheck");
UnitTestType = TEXT("DevExploit");
// Date reflects ReVuln doc, not the date I coded this up
UnitTestDate = FDateTime(2014, 06, 20);
UnitTestBugTrackIDs.Add(TEXT("TTP #335193"));
UnitTestBugTrackIDs.Add(TEXT("TTP #335195"));
UnitTestBugTrackIDs.Add(TEXT("JIRA UE-4225"));
UnitTestBugTrackIDs.Add(TEXT("JIRA UE-4209"));
ExpectedResult.Add(TEXT("ShooterGame"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("QAGame"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("UnrealTournament"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("FortniteGame"), EUnitTestVerification::VerifiedFixed);
UnitTestTimeout = 60;
UnitTestFlags |= (EUnitTestFlags::LaunchServer | EUnitTestFlags::AcceptActors | EUnitTestFlags::NotifyNetActors |
EUnitTestFlags::AcceptPlayerController | EUnitTestFlags::RequirePlayerController | EUnitTestFlags::SendRPCs |
EUnitTestFlags::ExpectServerCrash);
}
static void ParseFilesResults(const FP4RecordSet& InRecords, TArray< TSharedRef<ISourceControlRevision, ESPMode::ThreadSafe> >& OutRevisions, const FString& InClientRoot)
{
// Iterate over each record found as a result of the command, parsing it for relevant information
for (int32 Index = 0; Index < InRecords.Num(); ++Index)
{
const FP4Record& ClientRecord = InRecords[Index];
FString DepotFile = ClientRecord(TEXT("depotFile"));
FString RevisionNumber = ClientRecord(TEXT("rev"));
FString Date = ClientRecord(TEXT("time"));
FString ChangelistNumber = ClientRecord(TEXT("change"));
FString Action = ClientRecord(TEXT("action"));
check(RevisionNumber.Len() != 0);
// @todo: this revision is incomplete, but is sufficient for now given the usage of labels to get files, rather
// than review revision histories.
TSharedRef<FPerforceSourceControlRevision, ESPMode::ThreadSafe> Revision = MakeShareable( new FPerforceSourceControlRevision() );
Revision->FileName = DepotFile;
Revision->RevisionNumber = FCString::Atoi(*RevisionNumber);
Revision->ChangelistNumber = FCString::Atoi(*ChangelistNumber);
Revision->Action = Action;
Revision->Date = FDateTime(1970, 1, 1, 0, 0, 0, 0) + FTimespan(0, 0, FCString::Atoi(*Date));
OutRevisions.Add(Revision);
}
}
bool FDateTime::Parse( const FString& DateTimeString, FDateTime& OutDateTime )
{
// first replace -, : and . with space
FString FixedString = DateTimeString.Replace(TEXT("-"), TEXT(" "));
FixedString.ReplaceInline(TEXT(":"), TEXT(" "));
FixedString.ReplaceInline(TEXT("."), TEXT(" "));
TArray<FString> Tokens;
// split up on a single delimiter
FixedString.ParseIntoArray(&Tokens, TEXT(" "), true);
// make sure it parsed it properly (within reason)
if ((Tokens.Num() < 6) || (Tokens.Num() > 7))
{
return false;
}
// convert the tokens to numbers
OutDateTime.Ticks = FDateTime(
FCString::Atoi(*Tokens[0]), // year
FCString::Atoi(*Tokens[1]), // month
FCString::Atoi(*Tokens[2]), // day
FCString::Atoi(*Tokens[3]), // hour
FCString::Atoi(*Tokens[4]), // minute
FCString::Atoi(*Tokens[5]), // second
Tokens.Num() > 6 ? FCString::Atoi(*Tokens[6]) : 0 // millisecond
).GetTicks();
// @todo gmp: need some better validation here
return true;
}
bool FP4DataCache::LoadFromLog(const FString& UnrealSyncListLog)
{
const FRegexPattern Pattern(TEXT("Label ([^ ]+) (\\d{4})/(\\d{2})/(\\d{2}) (\\d{2}):(\\d{2}):(\\d{2})")); // '.+\\n
FRegexMatcher Matcher(Pattern, UnrealSyncListLog);
while (Matcher.FindNext())
{
Labels.Add(FP4Label(
Matcher.GetCaptureGroup(1),
FDateTime(
FCString::Atoi(*Matcher.GetCaptureGroup(2)),
FCString::Atoi(*Matcher.GetCaptureGroup(3)),
FCString::Atoi(*Matcher.GetCaptureGroup(4)),
FCString::Atoi(*Matcher.GetCaptureGroup(5)),
FCString::Atoi(*Matcher.GetCaptureGroup(6)),
FCString::Atoi(*Matcher.GetCaptureGroup(7))
)));
}
Labels.Sort(
[](const FP4Label& LabelA, const FP4Label& LabelB)
{
return LabelA.GetDate() > LabelB.GetDate();
});
return true;
}
UMovementTracker::UMovementTracker()
{
//Default values, accessible from the editor
WritePosition = false;
ReadPosition = false;
RefreshTime = 0.01f;
TimeLength = 1.0f;
//Other values used in this Plugin
WorldSet = false;
ElapsedTime = 0.0f;
ElapsedTimeSinceLastCheck = 0.0f;
bWantsBeginPlay = true;
PrimaryComponentTick.bCanEverTick = true;
DirectoryPath = FString(FPaths::GameDir() + "/Data/MovementTracker");
FPaths::NormalizeDirectoryName(DirectoryPath);
FileName = DirectoryPath + "/" + FDateTime().Now().ToString() + ".csv";
DirectoryExists = VerifyOrCreateDirectory(DirectoryPath);
PathStartArray = TArray<size_t>();
//The lists of lists: Each list contained in these lists corresponds to one CSV file, one path, and are all in the same position.
VectorList = TArray<TArray<FVector>>();
TimeList = TArray<TArray<float>>();
NameList = TArray<TArray<FString>>();
}
// Called every frame
void UMovementTracker::TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
ElapsedTime += DeltaTime;
ElapsedTimeSinceLastCheck += DeltaTime;
//If the time between two recording was reached
if (ElapsedTimeSinceLastCheck >= RefreshTime)
{
//Writes the comma-seprated values that are obeserved
if (WritePosition)
{
ActorPosition = GetOwner()->GetActorLocation();
FString line = FString::SanitizeFloat(ActorPosition.X) + "," +
FString::SanitizeFloat(ActorPosition.Y) + "," +
FString::SanitizeFloat(ActorPosition.Z) + "," +
FString::SanitizeFloat(ElapsedTime) + "," +
FString::FromInt((int)FDateTime().Now().ToUnixTimestamp()) + "," +
GetOwner()->GetName();
WriteToCurrentFile(line);
}
ElapsedTimeSinceLastCheck = 0.0f;
}
//Tries to get the world containing the actor until it succeeds
if (!WorldSet)
WorldSet = GetActorWorld();
//Draws the paths
if (WorldSet && ReadPosition)
DrawDebugPaths();
}
UPacketLimitTest::UPacketLimitTest(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
, bUseOodle(false)
, TestStage(ELimitTestStage::LTS_LowLevel_AtLimit)
, LastSendSize(0)
, LastSocketSendSize(0)
, TargetSocketSendSize(0)
{
UnitTestName = TEXT("PacketLimitTest");
UnitTestType = TEXT("Test");
UnitTestDate = FDateTime(2015, 12, 23);
bWorkInProgress = true;
// @todo #JohnBExploitCL: Bugtracking/changelist notes
ExpectedResult.Add(TEXT("ShooterGame"), EUnitTestVerification::VerifiedNotFixed);
UnitTestTimeout = 60;
UnitTestFlags |= (EUnitTestFlags::LaunchServer | EUnitTestFlags::SkipControlJoin | EUnitTestFlags::AutoReconnect |
EUnitTestFlags::RequirePing | EUnitTestFlags::CaptureSendRaw);
}
UFTextCrash::UFTextCrash(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
, ExploitFailLog(TEXT("Blank exploit fail log message"))
{
UnitTestName = TEXT("FTextCrash");
UnitTestType = TEXT("Exploit");
UnitTestDate = FDateTime(2014, 07, 11);
UnitTestBugTrackIDs.Add(TEXT("JIRA UE-5691"));
UnitTestCLs.Add(TEXT("2367048 (//depot/UE4/)"));
ExpectedResult.Add(TEXT("ShooterGame"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("QAGame"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("UnrealTournament"), EUnitTestVerification::VerifiedFixed);
ExpectedResult.Add(TEXT("FortniteGame"), EUnitTestVerification::VerifiedFixed);
UnitTestTimeout = 60;
UnitTestFlags |= (EUnitTestFlags::LaunchServer | EUnitTestFlags::AcceptActors | EUnitTestFlags::AcceptPlayerController |
EUnitTestFlags::SendRPCs | EUnitTestFlags::NotifyNetActors | EUnitTestFlags::RequireNUTActor |
EUnitTestFlags::ExpectServerCrash);
}
FDateTime FDateTime::UtcNow( )
{
int32 Year, Month, Day, DayOfWeek;
int32 Hour, Minute, Second, Millisecond;
FPlatformTime::UtcTime(Year, Month, DayOfWeek, Day, Hour, Minute, Second, Millisecond);
return FDateTime(Year, Month, Day, Hour, Minute, Second, Millisecond);
}
UVMReflection::UVMReflection(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
UnitTestName = TEXT("VMReflection");
UnitTestType = TEXT("Test");
UnitTestDate = FDateTime(2015, 3, 23);
ExpectedResult.Add(TEXT("NullUnitEnv"), EUnitTestVerification::VerifiedFixed);
UnitTestTimeout = 60;
}
static bool TryGetDirectoryCreationTimeUtc(const FString& InDirectoryName, FDateTime& OutCreationTime)
{
FString DirectoryName(InDirectoryName);
FPaths::MakePlatformFilename(DirectoryName);
WIN32_FILE_ATTRIBUTE_DATA Info;
if (!GetFileAttributesExW(*DirectoryName, GetFileExInfoStandard, &Info))
{
OutCreationTime = FDateTime();
return false;
}
SYSTEMTIME SysTime;
if (!FileTimeToSystemTime(&Info.ftCreationTime, &SysTime))
{
OutCreationTime = FDateTime();
return false;
}
OutCreationTime = FDateTime(SysTime.wYear, SysTime.wMonth, SysTime.wDay, SysTime.wHour, SysTime.wMinute, SysTime.wSecond);
return true;
}
UKIRCTopicQueryCommandResponseScanner::UKIRCTopicQueryCommandResponseScanner( const class FObjectInitializer& ObjectInitializer )
: Super( ObjectInitializer )
{
CommandCallbacks.Add( UKIRCClient::NumericToString( UKIRCClient::GetNumerics().ErrorNeedMoreParams ) );
CommandCallbacks.Add( UKIRCClient::NumericToString( UKIRCClient::GetNumerics().ErrorNoChanModes ) );
CommandCallbacks.Add( UKIRCClient::NumericToString( UKIRCClient::GetNumerics().ReplyTopic ) );
CommandCallbacks.Add( UKIRCClient::NumericToString( UKIRCClient::GetNumerics().ReplyTopicSetBy ) );
CommandCallbacks.Add( UKIRCClient::NumericToString( UKIRCClient::GetNumerics().ReplyNoTopic ) );
bHasTopic = false;
TopicBody = "";
AuthorNickName = "";
AuthorIdent = "";
AuthorHost = "";
TopicDate = FDateTime( 0 );
}
FDateTime FDateTimeStructCustomization::ConvertTime(const FDateTime& InDate, int32 InTimezone, int32 OutTimezone)
{
if (InTimezone == OutTimezone)
{
return InDate;
}
// Timezone Hour ranges go from -12 to +14 from UTC
// Convert from whole-hour to the full-format HHMM (-5 -> -0500, 0 -> +0000, etc)
InTimezone = ConvertShortTimezone(InTimezone);
OutTimezone = ConvertShortTimezone(OutTimezone);
// Extract timezone minutes
const int32 InTimezoneMinutes = (FMath::Abs(InTimezone) % 100);
const int32 OutTimezoneMinutes = (FMath::Abs(OutTimezone) % 100);
// Calculate our Minutes difference
const int32 MinutesDifference = OutTimezoneMinutes - InTimezoneMinutes;
// Calculate our Hours difference
const int64 HoursDifference = (OutTimezone / 100) - (InTimezone / 100);
return FDateTime(InDate + FTimespan(HoursDifference, MinutesDifference, 0));
}
UUpdateManager::UUpdateManager()
: HotfixCheckCompleteDelay(0.1f)
, UpdateCheckCompleteDelay(0.5f)
, HotfixAvailabilityCheckCompleteDelay(0.1f)
, UpdateCheckAvailabilityCompleteDelay(0.1f)
, bPlatformEnvironmentDetected(false)
, bInitialUpdateFinished(false)
, bCheckHotfixAvailabilityOnly(false)
, CurrentUpdateState(EUpdateState::UpdateIdle)
, WorstNumFilesPendingLoadViewed(0)
, LastPatchCheckResult(EPatchCheckResult::PatchCheckFailure)
, LastHotfixResult(EHotfixResult::Failed)
, LoadStartTime(0.0)
, UpdateStateEnum(nullptr)
, UpdateCompletionEnum(nullptr)
{
LastUpdateCheck[0] = LastUpdateCheck[1] = FDateTime(0);
LastCompletionResult[0] = LastCompletionResult[1] = EUpdateCompletionStatus::UpdateUnknown;
if (!HasAnyFlags(RF_ClassDefaultObject))
{
UpdateStateEnum = FindObject<UEnum>(ANY_PACKAGE, TEXT("EUpdateState"));
UpdateCompletionEnum = FindObject<UEnum>(ANY_PACKAGE, TEXT("EUpdateCompletionStatus"));
}
}
bool TimeHandler::isRunning(TimeCanal canal)
{
return startTime[(int)canal] != FDateTime(0);
}
void TimeHandler::StopTimer(TimeCanal canal)
{
if (isRunning(canal))
startTime[(int)canal] = FDateTime(0);
}
FDateTime ATimeManager::ConvertToDateTime(FTimeDate td)
{
return FDateTime(td.Year, td.Month, td.Day, td.Hour, td.Minute, td.Second, td.Millisecond);
}
void UUpdateManager::Reset()
{
LastUpdateCheck[0] = LastUpdateCheck[1] = FDateTime(0);
SetUpdateState(EUpdateState::UpdatePending);
}
/* DateTime functions
*****************************************************************************/
FDateTime UKismetMathLibrary::MakeDateTime(int32 Year, int32 Month, int32 Day, int32 Hour, int32 Minute, int32 Second, int32 Millisecond)
{
return FDateTime(Year, Month, Day, Hour, Minute, Second, Millisecond);
}
void FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished( FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded )
{
check( HttpState == EHttptate::EnumeratingSessions );
HttpState = EHttptate::Idle;
if ( bSucceeded && HttpResponse->GetResponseCode() == EHttpResponseCodes::Ok )
{
UE_LOG( LogHttpReplay, Verbose, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished." ) );
TArray<FNetworkReplayStreamInfo> Streams;
FString StreamsString = HttpResponse->GetContentAsString();
int32 Index = INDEX_NONE;
TArray< FString > Tokens;
// Parse the string as { token 1, token ..., token n }
// This isn't perfect, we should convert to JSON when the dust settles
if ( StreamsString.FindChar( '{', Index ) )
{
StreamsString = StreamsString.RightChop( Index + 1 );
while ( StreamsString.FindChar( ',', Index ) )
{
Tokens.Add( StreamsString.Left( Index ) );
StreamsString = StreamsString.RightChop( Index + 1 );
}
if ( StreamsString.FindChar( '}', Index ) )
{
Tokens.Add( StreamsString.Left( Index ) );
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. '}' not found." ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
if ( Tokens.Num() > 0 )
{
Tokens[ Tokens.Num() - 1 ].RemoveFromStart( TEXT( " " ) );
Tokens[ Tokens.Num() - 1 ].RemoveFromEnd( TEXT( " " ) );
}
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. '{' not found." ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
const int NUM_TOKENS_PER_INFO = 6;
if ( Tokens.Num() == 0 || ( Tokens.Num() % NUM_TOKENS_PER_INFO ) != 0 )
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. Invalid number of tokens: %i" ), Tokens.Num() );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
return;
}
// Convert tokens to individual FNetworkReplayStreamInfo's
for ( int i = 0; i < Tokens.Num(); i += NUM_TOKENS_PER_INFO )
{
FNetworkReplayStreamInfo NewStream;
NewStream.Name = Tokens[i];
NewStream.bIsLive = false;
NewStream.SizeInBytes = 0;
NewStream.Timestamp = 0;
if ( Tokens.IsValidIndex( i + 1 ) )
{
// Server returns milliseconds from January 1, 1970, 00:00:00 GMT
// We need to compensate for the fact that FDateTime starts at January 1, 0001 A.D. and is in 100 nanosecond resolution
NewStream.Timestamp = FDateTime( FCString::Atoi64( *Tokens[ i + 1 ] ) * 1000 * 10 + FDateTime( 1970, 1, 1 ).GetTicks() );
}
if ( Tokens.IsValidIndex( i + 2 ) )
{
NewStream.SizeInBytes = FCString::Atoi( *Tokens[ i + 2 ] );
}
if ( Tokens.IsValidIndex( i + 3 ) )
{
NewStream.LengthInMS = FCString::Atoi( *Tokens[ i + 3 ] );
}
if ( Tokens.IsValidIndex( i + 4 ) )
{
NewStream.NumViewers = FCString::Atoi( *Tokens[ i + 4 ] );
}
if ( Tokens.IsValidIndex( i + 5 ) )
{
NewStream.bIsLive = Tokens[ i + 5 ].Contains( TEXT( "true" ) );
}
Streams.Add( NewStream );
}
EnumerateStreamsDelegate.ExecuteIfBound( Streams );
}
else
{
UE_LOG( LogHttpReplay, Warning, TEXT( "FHttpNetworkReplayStreamer::HttpEnumerateSessionsFinished. FAILED" ) );
EnumerateStreamsDelegate.ExecuteIfBound( TArray<FNetworkReplayStreamInfo>() ); // FIXME: Notify failure here
}
EnumerateStreamsDelegate = FOnEnumerateStreamsComplete();
}
static void ParseHistoryResults(const FP4RecordSet& InRecords, const TArray<FPerforceSourceControlState>& InStates, FPerforceUpdateStatusWorker::FHistoryMap& OutHistory)
{
if (InRecords.Num() > 0)
{
// Iterate over each record, extracting the relevant information for each
for (int32 RecordIndex = 0; RecordIndex < InRecords.Num(); ++RecordIndex)
{
const FP4Record& ClientRecord = InRecords[RecordIndex];
// Extract the file name
check(ClientRecord.Contains(TEXT("depotFile")));
FString DepotFileName = ClientRecord(TEXT("depotFile"));
FString LocalFileName = FindWorkspaceFile(InStates, DepotFileName);
TArray< TSharedRef<FPerforceSourceControlRevision, ESPMode::ThreadSafe> > Revisions;
int32 RevisionNumbers = 0;
for (;;)
{
// Extract the revision number
FString VarName = FString::Printf(TEXT("rev%d"), RevisionNumbers);
if (!ClientRecord.Contains(*VarName))
{
// No more revisions
break;
}
FString RevisionNumber = ClientRecord(*VarName);
// Extract the user name
VarName = FString::Printf(TEXT("user%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString UserName = ClientRecord(*VarName);
// Extract the date
VarName = FString::Printf(TEXT("time%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString Date = ClientRecord(*VarName);
// Extract the changelist number
VarName = FString::Printf(TEXT("change%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString ChangelistNumber = ClientRecord(*VarName);
// Extract the description
VarName = FString::Printf(TEXT("desc%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString Description = ClientRecord(*VarName);
// Extract the action
VarName = FString::Printf(TEXT("action%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString Action = ClientRecord(*VarName);
FString FileSize(TEXT("0"));
// Extract the file size
if(Action.ToLower() != TEXT("delete") && Action.ToLower() != TEXT("move/delete")) //delete actions don't have a fileSize from PV4
{
VarName = FString::Printf(TEXT("fileSize%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FileSize = ClientRecord(*VarName);
}
// Extract the clientspec/workspace
VarName = FString::Printf(TEXT("client%d"), RevisionNumbers);
check(ClientRecord.Contains(*VarName));
FString ClientSpec = ClientRecord(*VarName);
// check for branch
TSharedPtr<FPerforceSourceControlRevision, ESPMode::ThreadSafe> BranchSource;
VarName = FString::Printf(TEXT("how%d,0"), RevisionNumbers);
if(ClientRecord.Contains(*VarName))
{
BranchSource = MakeShareable( new FPerforceSourceControlRevision() );
VarName = FString::Printf(TEXT("file%d,0"), RevisionNumbers);
FString BranchSourceFileName = ClientRecord(*VarName);
BranchSource->FileName = FindWorkspaceFile(InStates, BranchSourceFileName);
VarName = FString::Printf(TEXT("erev%d,0"), RevisionNumbers);
FString BranchSourceRevision = ClientRecord(*VarName);
BranchSource->RevisionNumber = FCString::Atoi(*BranchSourceRevision);
}
TSharedRef<FPerforceSourceControlRevision, ESPMode::ThreadSafe> Revision = MakeShareable( new FPerforceSourceControlRevision() );
Revision->FileName = LocalFileName;
Revision->RevisionNumber = FCString::Atoi(*RevisionNumber);
Revision->Revision = RevisionNumber;
Revision->ChangelistNumber = FCString::Atoi(*ChangelistNumber);
Revision->Description = Description;
Revision->UserName = UserName;
Revision->ClientSpec = ClientSpec;
Revision->Action = Action;
Revision->BranchSource = BranchSource;
Revision->Date = FDateTime(1970, 1, 1, 0, 0, 0, 0) + FTimespan::FromSeconds(FCString::Atoi(*Date));
Revision->FileSize = FCString::Atoi(*FileSize);
Revisions.Add(Revision);
RevisionNumbers++;
}
if(Revisions.Num() > 0)
{
OutHistory.Add(LocalFileName, Revisions);
}
}
}
}
// Fill out your copyright notice in the Description page of Project Settings.
#include "LeBrutaliste.h"
#include "TimeHandler.h"
FDateTime TimeHandler::startTime[7] = { FDateTime(0) };
void TimeHandler::startTimer(TimeCanal canal)
{
if (!isRunning(canal))
startTime[(int)canal] = FDateTime::Now();
}
FTimespan TimeHandler::TimeElapsed(TimeCanal canal)
{
if (isRunning(canal))
return FDateTime::Now() - startTime[(int)canal];
else
return FTimespan(0);
}
int32 TimeHandler::TimeElapsedInMinutes(TimeCanal canal)
{
return TimeElapsed(canal).GetMinutes();
}
int32 TimeHandler::TimeElapsedInSeconds(TimeCanal canal)
{
return TimeElapsed(canal).GetSeconds();
}
