void Client::SetLoginProperty(String key, Urho3D::Variant value)
{
key = key.Trimmed();
if (value.IsEmpty())
properties_.Erase(properties_.Find(key));
else
properties_[key] = value;
}
String AddTrailingSlash(const String& pathName)
{
String ret = pathName.Trimmed();
ret.Replace('\\', '/');
if (!ret.Empty() && ret.Back() != '/')
ret += '/';
return ret;
}
String RemoveTrailingSlash(const String& pathName)
{
String ret = pathName.Trimmed();
ret.Replace('\\', '/');
if (!ret.Empty() && ret.Back() == '/')
ret.Resize(ret.Length() - 1);
return ret;
}
Variant Material::ParseShaderParameterValue(const String& value)
{
String valueTrimmed = value.Trimmed();
if (valueTrimmed.Length() && IsAlpha(valueTrimmed[0]))
return Variant(ToBool(valueTrimmed));
else
return ToVectorVariant(valueTrimmed);
}
Urho3D::Variant Client::LoginProperty(String key) const
{
key = key.Trimmed();
auto i = properties_.Find(key);
if (i != properties_.End())
return i.ptr_;
else
return Urho3D::Variant();
}
void FileFilter::AddExtension( const String& ext )
{
String x = ext.Trimmed();
if ( !x.StartsWith( '.' ) )
if ( !x.StartsWith( '*' ) )
x = '*' + x;
x.ToLowercase(); // case-insensitive file extensions
if ( !extensions.Contains( x ) )
extensions.Add( x );
}
void WebRequest::SetRequestHeader(const String& key, const String& value)
{
// Trim and only add non-empty header strings.
String header;
header += key.Trimmed();
header += ": ";
header += value;
if (header.Length())
{
is_->headers = curl_slist_append(is_->headers, header.CString());
}
}
AssetTransferPtr HttpAssetProvider::RequestAsset(String assetRef, String assetType)
{
assetRef = assetRef.Trimmed();
HttpRequestPtr request = client_->Get(assetRef);
if (!request)
return AssetTransferPtr();
AssetTransferPtr transfer(new HttpAssetTransfer(this, request, assetRef, assetType));
transfer->provider = this;
return transfer;
}
WebRequest::WebRequest(Context* context, const String& verb, const String& url, double requestContentSize) :
Object(context),
is_(new WebRequestInternalState(*this))
{
is_->url = url.Trimmed();
is_->verb = verb;
is_->upload = new BufferQueue(context);
is_->download = new BufferQueue(context);
is_->state = HTTP_INITIALIZING;
is_->curlm = NULL;
is_->curl = NULL;
is_->requestContentSize = curl_off_t(std::floor(requestContentSize));
is_->isAborted = false;
is_->isAddedToMulti = false;
}
void Client::Login(const String& address, unsigned short port, const String& username, const String& password, const String &protocol)
{
if (IsConnected())
DoLogout();
// Set properties that the "lower" overload wont be adding.
SetLoginProperty("username", username);
SetLoginProperty("password", password);
String p = protocol.Trimmed().ToLower();
kNet::SocketTransportLayer transportLayer = kNet::StringToSocketTransportLayer(p.CString());
if (transportLayer == kNet::InvalidTransportLayer && !p.Empty())
{
LogError("Client::Login: Cannot log to server using unrecognized protocol: " + p);
return;
}
Login(address, port, transportLayer);
}
HttpRequest::HttpRequest(const String& url, const String& verb, const Vector<String>& headers, const String& postData) :
url_(url.Trimmed()),
verb_(!verb.Empty() ? verb : "GET"),
headers_(headers),
postData_(postData),
state_(HTTP_INITIALIZING),
httpReadBuffer_(new unsigned char[READ_BUFFER_SIZE]),
readBuffer_(new unsigned char[READ_BUFFER_SIZE]),
readPosition_(0),
writePosition_(0)
{
// Size of response is unknown, so just set maximum value. The position will also be changed
// to maximum value once the request is done, signaling end for Deserializer::IsEof().
size_ = M_MAX_UNSIGNED;
LOGDEBUG("HTTP " + verb_ + " request to URL " + url_);
// Start the worker thread to actually create the connection and read the response data.
Run();
}
void StaticModel::ApplyMaterialList(const String& fileName)
{
String useFileName = fileName;
if (useFileName.Trimmed().Empty() && model_)
useFileName = ReplaceExtension(model_->GetName(), ".txt");
ResourceCache* cache = GetSubsystem<ResourceCache>();
SharedPtr<File> file = cache->GetFile(useFileName, false);
if (!file)
return;
unsigned index = 0;
while (!file->IsEof() && index < batches_.Size())
{
Material* material = cache->GetResource<Material>(file->ReadLine());
if (material)
SetMaterial(index, material);
++index;
}
}
void ParseCommand(String input, String &command, StringVector ¶meters)
{
input = input.Trimmed();
if (input.Empty())
return;
uint parenPos = input.Find('(', 0);
uint spacePos = input.Find(' ', 0);
if (parenPos == String::NPOS && spacePos == String::NPOS)
{
command = input;
return;
}
StringVector parts;
if (parenPos != String::NPOS && parenPos < spacePos)
{
uint parenEndPos = input.FindLast(')');
String insideParens = (parenEndPos != String::NPOS ?
input.Substring(parenPos+1, parenEndPos-parenPos-1).Trimmed() : input.Substring(parenPos+1).Trimmed());
command = input.Substring(0, parenPos).Trimmed();
// "one, two, three", "one,two,three" and "one two three"
parts = insideParens.Contains(',') ? insideParens.Split(',') : insideParens.Split(' ');
}
else
{
command = input.Substring(0, spacePos).Trimmed();
String remaining = input.Substring(spacePos+1).Trimmed();
// "one, two, three", "one,two,three" and "one two three"
parts = remaining.Contains(',') ? remaining.Split(',') : remaining.Split(' ');
}
for(StringVector::Iterator iter=parts.Begin(); iter!=parts.End(); ++iter)
{
String part = (*iter).Trimmed();
if (part.EndsWith(","))
part = part.Substring(0, part.Length()-1);
if (!part.Empty())
parameters.Push(part);
}
}
DbResult DbConnection::Execute(const String& sql, bool useCursorEvent)
{
DbResult result;
try
{
result.resultImpl_ = nanodbc::execute(connectionImpl_, sql.Trimmed().CString());
unsigned numCols = (unsigned)result.resultImpl_.columns();
if (numCols)
{
result.columns_.Resize(numCols);
for (unsigned i = 0; i < numCols; ++i)
result.columns_[i] = result.resultImpl_.column_name((short)i).c_str();
bool filtered = false;
bool aborted = false;
while (result.resultImpl_.next())
{
VariantVector colValues(numCols);
for (unsigned i = 0; i < numCols; ++i)
{
if (!result.resultImpl_.is_null((short)i))
{
// We can only bind primitive data type that our Variant class supports
switch (result.resultImpl_.column_c_datatype((short)i))
{
case SQL_C_LONG:
colValues[i] = result.resultImpl_.get<int>((short)i);
if (result.resultImpl_.column_datatype((short)i) == SQL_BIT)
colValues[i] = colValues[i] != 0;
break;
case SQL_C_FLOAT:
colValues[i] = result.resultImpl_.get<float>((short)i);
break;
case SQL_C_DOUBLE:
colValues[i] = result.resultImpl_.get<double>((short)i);
break;
default:
// All other types are stored using their string representation in the Variant
colValues[i] = result.resultImpl_.get<nanodbc::string>((short)i).c_str();
break;
}
}
}
if (useCursorEvent)
{
using namespace DbCursor;
VariantMap& eventData = GetEventDataMap();
eventData[P_DBCONNECTION] = this;
eventData[P_RESULTIMPL] = &result.resultImpl_;
eventData[P_SQL] = sql;
eventData[P_NUMCOLS] = numCols;
eventData[P_COLVALUES] = colValues;
eventData[P_COLHEADERS] = result.columns_;
eventData[P_FILTER] = false;
eventData[P_ABORT] = false;
SendEvent(E_DBCURSOR, eventData);
filtered = eventData[P_FILTER].GetBool();
aborted = eventData[P_ABORT].GetBool();
}
if (!filtered)
result.rows_.Push(colValues);
if (aborted)
break;
}
}
result.numAffectedRows_ = numCols ? -1 : result.resultImpl_.affected_rows();
}
catch (std::runtime_error& e)
{
HandleRuntimeError("Could not execute", e.what());
}
return result;
}
void AssetRefListener::HandleAssetRefChange(AssetAPI *assetApi, String assetRef, const String& assetType)
{
// Disconnect from any previous transfer we might be listening to
if (!currentTransfer.Expired())
{
IAssetTransfer* current = currentTransfer.Get();
current->Succeeded.Disconnect(this, &AssetRefListener::OnTransferSucceeded);
current->Failed.Disconnect(this, &AssetRefListener::OnTransferFailed);
currentTransfer.Reset();
}
assert(assetApi);
// Store AssetAPI ptr for later signal hooking.
if (!myAssetAPI)
myAssetAPI = assetApi;
// If the ref is empty, don't go any further as it will just trigger the LogWarning below.
assetRef = assetRef.Trimmed();
if (assetRef.Empty())
{
asset = AssetPtr();
return;
}
currentWaitingRef = "";
// Resolve the protocol for generated:// assets. These assets are never meant to be
// requested from AssetAPI, they cannot be fetched from anywhere. They can only be either
// loaded or we must wait for something to load/create them.
String protocolPart = "";
assetApi->ParseAssetRef(assetRef, &protocolPart);
if (protocolPart.ToLower() == "generated")
{
AssetPtr loadedAsset = assetApi->FindAsset(assetRef);
if (loadedAsset.Get() && loadedAsset->IsLoaded())
{
// Asset is loaded, emit Loaded with 1 msec delay to preserve the logic
// that HandleAssetRefChange won't emit anything itself as before.
// Otherwise existing connection can break/be too late after calling this function.
asset = loadedAsset;
assetApi->GetFramework()->Frame()->DelayedExecute(0.0f).Connect(this, &AssetRefListener::EmitLoaded);
return;
}
else
{
// Wait for it to be created.
currentWaitingRef = assetRef;
myAssetAPI->AssetCreated.Connect(this, &AssetRefListener::OnAssetCreated);
}
}
else
{
// This is not a generated asset, request normally from asset api.
AssetTransferPtr transfer = assetApi->RequestAsset(assetRef, assetType);
if (!transfer)
{
LogWarning("AssetRefListener::HandleAssetRefChange: Asset request for asset \"" + assetRef + "\" failed.");
return;
}
currentWaitingRef = assetRef;
transfer->Succeeded.Connect(this, &AssetRefListener::OnTransferSucceeded);
transfer->Failed.Connect(this, &AssetRefListener::OnTransferFailed);
currentTransfer = transfer;
}
// Disconnect from the old asset's load signal
if (asset)
asset->Loaded.Disconnect(this, &AssetRefListener::OnAssetLoaded);
asset = AssetPtr();
}
DbResult DbConnection::Execute(const String& sql, bool useCursorEvent)
{
DbResult result;
const char* zLeftover = 0;
sqlite3_stmt* pStmt = 0;
assert(connectionImpl_);
int rc = sqlite3_prepare_v2(connectionImpl_, sql.Trimmed().CString(), -1, &pStmt, &zLeftover);
if (rc != SQLITE_OK)
{
LOGERRORF("Could not execute: %s", sqlite3_errmsg(connectionImpl_));
assert(!pStmt);
return result;
}
if (*zLeftover)
{
LOGERROR("Could not execute: only one SQL statement is allowed");
sqlite3_finalize(pStmt);
return result;
}
unsigned numCols = (unsigned)sqlite3_column_count(pStmt);
result.columns_.Resize(numCols);
for (unsigned i = 0; i < numCols; ++i)
result.columns_[i] = sqlite3_column_name(pStmt, i);
bool filtered = false;
bool aborted = false;
while (1)
{
rc = sqlite3_step(pStmt);
if (rc == SQLITE_ROW)
{
VariantVector colValues(numCols);
for (unsigned i = 0; i < numCols; ++i)
{
int type = sqlite3_column_type(pStmt, i);
if (type != SQLITE_NULL)
{
// We can only bind primitive data type that our Variant class supports
switch (type)
{
case SQLITE_INTEGER:
colValues[i] = sqlite3_column_int(pStmt, i);
if (String(sqlite3_column_decltype(pStmt, i)).Compare("BOOLEAN", false) == 0)
colValues[i] = colValues[i] != 0;
break;
case SQLITE_FLOAT:
colValues[i] = sqlite3_column_double(pStmt, i);
break;
default:
// All other types are stored using their string representation in the Variant
colValues[i] = (const char*)sqlite3_column_text(pStmt, i);
break;
}
}
}
if (useCursorEvent)
{
using namespace DbCursor;
VariantMap& eventData = GetEventDataMap();
eventData[P_DBCONNECTION] = this;
eventData[P_RESULTIMPL] = pStmt;
eventData[P_SQL] = sql;
eventData[P_NUMCOLS] = numCols;
eventData[P_COLVALUES] = colValues;
eventData[P_COLHEADERS] = result.columns_;
eventData[P_FILTER] = false;
eventData[P_ABORT] = false;
SendEvent(E_DBCURSOR, eventData);
filtered = eventData[P_FILTER].GetBool();
aborted = eventData[P_ABORT].GetBool();
}
if (!filtered)
result.rows_.Push(colValues);
if (aborted)
{
sqlite3_finalize(pStmt);
break;
}
}
else if (rc != SQLITE_DONE)
LOGERRORF("Could not execute: %s", sqlite3_errmsg(connectionImpl_));
if (rc != SQLITE_ROW)
{
sqlite3_finalize(pStmt);
break;
}
}
result.numAffectedRows_ = numCols ? -1 : sqlite3_changes(connectionImpl_);
return result;
}
bool HttpAssetProvider::IsValidRef(String assetRef, String assetType) const
{
// http and https are valid
assetRef = assetRef.Trimmed().ToLower();
return (assetRef.StartsWith("http://") || assetRef.StartsWith("https://"));
}
void ShaderVariation::SetName(const String& name)
{
name_ = name.Trimmed().Replaced(' ', '_');
}
/// Actual thread function
void GameEconomicServerClientConsole::ThreadFunction()
{
/// Get network subsystem
Network* network = GetSubsystem<Network>();
bool success=false;
bool lineEntered=false;
/// turn on inteface
bool isActiveFlag=true;
/// Urho related variables
String PromptInput;
String ConsoleInputLine;
Connection* serverConnection;
/// Show prompt
ShowPrompt();
/// Clear prompt input
PromptInput.Clear();
ConsoleInputLine.Clear();
/// loop
do
{
ConsoleInputLine.Clear();
/// Get input from the user
ConsoleInputLine = GetConsoleInput();
/// append if its not empty
if(ConsoleInputLine.Length()>0)
{
/// prompt
PromptInput.Append(ConsoleInputLine);
lineEntered=true;
}
/// test if there was input
if(lineEntered==true&&PromptInput.Empty())
{
cout << "Invalid command.." << endl;
/// Clear prompt input
PromptInput.Clear();
///Display new prompt
ShowPrompt();
lineEntered=false;
}
else if (lineEntered==true)
{
/// Trim input to clean up
String CleanedPromptInput = PromptInput.Trimmed();
/// Test Commands
if(CleanedPromptInput==String("connect"))
{
Connect(NetworkConfiguration);
}
else if(CleanedPromptInput==String("quit"))
{
/// Terminate program forced
exit(0);
}
else
{
/// if server connection and serverConnection
if(serverconnection&&serverconnection)
{
/// Clean
SendMessage(CleanedPromptInput);
}
}
/// Clear prompt input
PromptInput.Clear();
///Display new prompt
ShowPrompt();
lineEntered=false;
}
}
while(isActiveFlag);
return;
}
void Graphics::SetShaderCacheDir(const String& path)
{
String trimmedPath = path.Trimmed();
if (trimmedPath.Length())
shaderCacheDir_ = AddTrailingSlash(trimmedPath);
}
void Graphics::SetOrientations(const String& orientations)
{
orientations_ = orientations.Trimmed();
SDL_SetHint(SDL_HINT_ORIENTATIONS, orientations_.CString());
}
