inline const unsigned char* string::data()
{
return ASN1_STRING_data(ptr().get());
}
bool isIdentity() const
{
mat2 i = I();
return memcmp( ptr(), i.ptr(), sizeof(GLfloat)*4 ) == 0;
}
Worker::ptr Worker::create(boost::asio::io_service& io_srv, boost::asio::ip::address_v4 ip)
{
return ptr(new Worker(io_srv, ip));
}
wxPieChartData::ptr wxPieChartData::make_shared()
{
return ptr(new wxPieChartData());
}
void CTrustSession::DispatchMessageL(const RMessage2& aMessage)
{
switch(aMessage.Function())
{
case EAddTrust:
{
TCertInfo certInfo;
TPckg<TCertInfo> certInfoPckg(certInfo);
aMessage.ReadL(1,certInfoPckg);
TInt err = Server().AddSessionTrustL(certInfo);
TPckg<TInt> result(err);
aMessage.WriteL(0,result);
}
break;
case EGetElementList:
{
RElementIdArray array;
CleanupClosePushL( array);
TElementType type = EPolicySets;
TPckgBuf<TInt> EleTypePkg(type);
aMessage.ReadL(1,EleTypePkg);
type =(TElementType) EleTypePkg();
TInt err = Server().GetElementListL(type,array);
TPckgBuf<TInt> result(err);
TInt count = array.Count();
aMessage.WriteL(0,result);
CleanupStack::PopAndDestroy();
}
break;
case EGetElement:
{
HBufC8* buffer = HBufC8::NewLC( 300 );
TPtr8 ptr( buffer->Des() );
aMessage.ReadL( 0, ptr );
TElementInfo elementInfo(ptr);
TPtrC8 ptrNullDes = elementInfo.GetDescription(); //just to get the code coverage
User::LeaveIfError( Server().GetElementL(elementInfo));
TPtrC8 ptrDes = elementInfo.GetDescription();
TPtrC8 ptrID = elementInfo.GetElementId();
for ( TInt i = 0; i < elementInfo.GetChildElementArray().Count(); i++)
{
RDEBUG_2("CTrustSession::DispatchMessageL Child element ids %S", elementInfo.GetChildElementArray()[i]);
}
CleanupStack::PopAndDestroy(buffer);
}
break;
case EGetXACMLDescription:
{
HBufC8* buffer = HBufC8::NewLC( 300 );
TPtr8 ptr( buffer->Des() );
aMessage.ReadL( 0, ptr );
TElementInfo elementInfo(ptr);
TPtrC8 ptrNullXACML(elementInfo.GetXACML()); //just to get the code coverage
User::LeaveIfError( Server().GetXACMLDescriptionL(elementInfo));
TPtrC8 ptrXACML(elementInfo.GetXACML());
// RDEBUG_2("CTrustSession::DispatchMessageLGetXACML %S", ptrXACML);
CleanupStack::PopAndDestroy(buffer);
}
break;
default:
break;
}
}
void Item_group::add_item_entry(const Item_tag &itemid, int probability)
{
std::unique_ptr<Item_spawn_data> ptr(new Single_item_creator(itemid, Single_item_creator::S_ITEM, probability));
add_entry(ptr);
}
int Game::loadGamestate(const XMLReader& reader, const sf::String& GSname, const SFG::Pointer<GameState>& included)
{
SFG::Pointer<GameState> GS_ptr;
sf::String GSxmlpath = L"xml/gamestate[" + GSname + L"]";
auto str = reader.getValue(GSxmlpath, 0);
if (str == L"__xml_failure")
{
printf("[Error] Unspecified startup gamestate in %s:%d.\n", __FILE__, __LINE__);
return -2;
}
else
{
if (str == L"#included")
{
//Use default
GS_ptr.reset(included);
if (!GS_ptr.isValid() && included.getElement() != nullptr)
{
printf("[Critical] Failed to allocate memory for \"%s\" in %s:%d\n",GSname.toAnsiString().c_str(), __FILE__, __LINE__);
return -1;
}
}
else
{
//Use specified
//#TODO
STILL_TO_DO(__FILE__, __LINE__);
//We first need an instance of a DLLLoadedGameState
GS_ptr.reset(new DLLLoadedGameState());
//Set the name
GS_ptr->setName(GSname);
if (GS_ptr->getName() == "__xml_failure")
{
SFG::Util::printLog(SFG::Util::Error, __FILE__, __LINE__, "Failed to get Gamestate name, aborting.");
return -1;
}
//Then, load the specified file
if (GS_ptr.cast<DLLLoadedGameState>()->loadFromDll(str.toAnsiString().c_str()) != 0)
{
SFG::Util::printLog(SFG::Util::Error, __FILE__, __LINE__,
"Failed to load gamestate \"%s\" from DLL", str.toAnsiString().c_str());
return -2;
}
//We actually should be done
}
//Get all modules
sf::String uses = reader.getValue(GSxmlpath + L"uses.");
if (uses != L"__xml_failure")
{
//We have specifiers
size_t begin = 0;
size_t last = 0;
//Begin needs to be checked as the last module wouldn't be counted otherwise
while ((last = uses.find(L',', last)) != sf::String::InvalidPos || begin != sf::String::InvalidPos)
{
sf::String string;
if (last == sf::String::InvalidPos)
{
//If the end would otherwise exceed the string length, set it to the maximum (sf::String::end()).
//string = sf::String(uses.begin() + begin, uses.end());
string = uses.substring(begin, uses.getSize() - begin);
}
else
{
//If a ',' was found, use its position
//string = sf::String(uses.begin() + begin, uses.begin() + last);
string = uses.substring(begin, last - begin);
}
//Check for module names
if (string == L"G2D")
{
SFG::Pointer<ModuleG2D> ptr(new ModuleG2D());
if (!ptr.isValid())
{
char buf[512];
#ifdef _WIN32
strerror_s(buf, errno);
#else
strerror_r(errno, buf, 512);
#endif // _WIN32
printf("[Error] Failed to create Module G2D in %s:%d: %s\n", __FILE__, __LINE__, buf);
return -3;
}
GS_ptr->addModule(ptr);
}
else
{
//#TODO: Add more modules (sound etc.)
STILL_TO_DO(__FILE__, __LINE__);
}
if(last != sf::String::InvalidPos) begin = last + 1; //if a ',' was found, go search on for the next one
else begin = last; //Meaning begin is sf::String::npos
}
}
//Check for external asset list
auto ext_assets = reader.getValue(GSxmlpath + "assets.");
if (ext_assets != "__xml_failure")
{
//We found external assets, load them
}
auto assets = reader.getXMLGroupHandle(L"xml/assetlist[" + GSname + L"]");
if (assets == nullptr)
{
printf("[Warning] No assets for Gamestate \"%s\" found. This is not encouraged and might be an error. Please check the game.xml file. In: %s:%d\n", GSname.toAnsiString().c_str(), __FILE__, __LINE__);
//return 1;
}
else
{
auto ret = GS_ptr->loadAssets(XMLReader(*assets));
if (ret != 0)
{
printf("[Error] Failed to load assets for Gamestate \"%s\" in %s:%d.\n", GSname.toAnsiString().c_str(), __FILE__, __LINE__);
}
}
//Empty path to tell the gamestate to just update what it has (or do nothing if nothing has to be done)
GS_ptr->load(L"");
//this->g_gamestates.push_back(GS_ptr);
this->addGamestate(GS_ptr);
}
return 0;
}
int main(int argc, char* argv[]) {
using Test = venum::Enum
::Variant<std::string>
::Variant<int>
::Variant<Thing>;
std::vector<Test> v;
v.emplace_back(7);
v.emplace_back("Hello");
v.emplace_back(5);
v.emplace_back(5, 'a');
for(auto& t : v) {
t.match(
[](std::string& s) { std::cout << "string: " << s << std::endl; },
[](int& i) { std::cout << "int: " << i << std::endl; },
[](Thing& t) { std::cout << "thing: " << t.i << ", " << t.c << std::endl; }
);
std::cout << std::endl;
}
venum::Enum::Variant<int>::Variant<std::string>(7).apply([](auto a) { std::cout << a << std::endl; });
using Test2 = venum::Enum::Variant<int*>::Variant<int>::Variant<char>;
int z = 67;
Test2 a(5);
Test2 b('c');
Test2 ptr(&z);
auto c = Test2::construct<char>(47);
a.match(
[](int* i) { std::cout << "int* " << *i << std::endl; },
[](int& i) { std::cout << "int: " << i << std::endl; },
[](char& c) { std::cout << "char: " << c << std::endl; }
);
b.match(
[](int* i) { std::cout << "int* " << *i << std::endl; },
[](int& i) { std::cout << "int: " << i << std::endl; },
[](char& c) { std::cout << "char: " << c << std::endl; }
);
ptr.match(
[](int* i) { std::cout << "int* " << *i << std::endl; },
[](int& i) { std::cout << "int: " << i << std::endl; },
[](char& c) { std::cout << "char: " << c << std::endl; }
);
std::string s2 = a.match(
[](int* i) { std::ostringstream str; str << "int*: " << i; return str.str(); },
[](int i) { std::ostringstream str; str << "int: " << i; return str.str(); },
[](char c) { std::ostringstream str; str << "char: " << c; return str.str(); }
);
c.match(
[](int* i) { std::cout << "int* " << *i << std::endl; },
[](int& i) { std::cout << "int: " << i << std::endl; },
[](char& c) { std::cout << "char: " << c << std::endl; }
);
std::cout << c.which() << " " << c.contains<char>() << " " << c.contains<int>() << std::endl;
try {
std::cout << "not a real int: " << c.get<int>() << std::endl;
} catch(std::exception& e) {
std::cout << e.what() << std::endl;
}
std::cout << "not a real int: " << c.get_unchecked<int>() << std::endl;
// Optional Test
auto o = Optional<int>::Some(6);
if(o) {
std::cout << o.get() << std::endl;
}
try {
Optional<std::string>::None().get();
} catch(std::exception& e) {
std::cout << e.what() << std::endl;
}
std::string s = o.map([](int i) { return std::to_string(i); }).match(
[](None) { return std::string(""); },
[](std::string s) { return s; }
);
std::cout << "result: " << s << std::endl;
o.and_then([](int i) { return Optional<float>::None(); });
std::cout << std::endl;
// Tree Test
Tree<int> tree;
tree.insert(5);
tree.insert(2);
tree.insert(7);
tree.insert(3);
tree.insert(19);
tree.apply([](int i) { std::cout << i << std::endl; });
std::cout << tree.contains(19) << std::endl;
std::cout << tree.contains(8) << std::endl;
[]() {}();
}
CppObject * operator->() { return ptr(); }
static jl_value_t *scm_to_julia_(value_t e, int eo)
{
if (fl_isnumber(e)) {
int64_t i64;
if (isfixnum(e)) {
i64 = numval(e);
}
else {
assert(iscprim(e));
cprim_t *cp = (cprim_t*)ptr(e);
numerictype_t nt = cp_numtype(cp);
switch (nt) {
case T_DOUBLE:
return (jl_value_t*)jl_box_float64(*(double*)cp_data(cp));
case T_FLOAT:
return (jl_value_t*)jl_box_float32(*(float*)cp_data(cp));
case T_UINT8:
return (jl_value_t*)jl_box_uint8(*(uint8_t*)cp_data(cp));
case T_UINT16:
return (jl_value_t*)jl_box_uint16(*(uint16_t*)cp_data(cp));
case T_UINT32:
return (jl_value_t*)jl_box_uint32(*(uint32_t*)cp_data(cp));
case T_UINT64:
return (jl_value_t*)jl_box_uint64(*(uint64_t*)cp_data(cp));
default:
;
}
i64 = conv_to_int64(cp_data(cp), nt);
}
if (
#ifdef _P64
jl_compileropts.int_literals==32
#else
jl_compileropts.int_literals!=64
#endif
) {
if (i64 > (int64_t)S32_MAX || i64 < (int64_t)S32_MIN)
return (jl_value_t*)jl_box_int64(i64);
return (jl_value_t*)jl_box_int32((int32_t)i64);
}
else {
return (jl_value_t*)jl_box_int64(i64);
}
}
if (issymbol(e)) {
if (e == true_sym)
return jl_true;
else if (e == false_sym)
return jl_false;
return (jl_value_t*)scmsym_to_julia(e);
}
if (fl_isstring(e)) {
return jl_pchar_to_string((char*)cvalue_data(e), cvalue_len(e));
}
if (e == FL_F) {
return jl_false;
}
if (e == FL_T) {
return jl_true;
}
if (e == FL_NIL) {
return (jl_value_t*)jl_null;
}
if (iscons(e)) {
value_t hd = car_(e);
if (issymbol(hd)) {
jl_sym_t *sym = scmsym_to_julia(hd);
/* tree node types:
goto gotoifnot label return
lambda call = quote
null top method
body file new
line enter leave
*/
size_t n = llength(e)-1;
size_t i;
if (sym == null_sym && n == 0)
return jl_nothing;
if (sym == lambda_sym) {
jl_expr_t *ex = jl_exprn(lambda_sym, n);
e = cdr_(e);
value_t largs = car_(e);
jl_cellset(ex->args, 0, full_list(largs,eo));
e = cdr_(e);
value_t ee = car_(e);
jl_array_t *vinf = jl_alloc_cell_1d(3);
jl_cellset(vinf, 0, full_list(car_(ee),eo));
ee = cdr_(ee);
jl_cellset(vinf, 1, full_list_of_lists(car_(ee),eo));
ee = cdr_(ee);
jl_cellset(vinf, 2, full_list_of_lists(car_(ee),eo));
assert(!iscons(cdr_(ee)));
jl_cellset(ex->args, 1, vinf);
e = cdr_(e);
for(i=2; i < n; i++) {
assert(iscons(e));
jl_cellset(ex->args, i, scm_to_julia_(car_(e), eo));
e = cdr_(e);
}
return
(jl_value_t*)jl_new_lambda_info((jl_value_t*)ex, jl_null);
}
e = cdr_(e);
if (!eo) {
if (sym == line_sym && n==1) {
return jl_new_struct(jl_linenumbernode_type,
scm_to_julia_(car_(e),0));
}
if (sym == label_sym) {
return jl_new_struct(jl_labelnode_type,
scm_to_julia_(car_(e),0));
}
if (sym == goto_sym) {
return jl_new_struct(jl_gotonode_type,
scm_to_julia_(car_(e),0));
}
if (sym == quote_sym) {
return jl_new_struct(jl_quotenode_type,
scm_to_julia_(car_(e),0));
}
if (sym == top_sym) {
return jl_new_struct(jl_topnode_type,
scm_to_julia_(car_(e),0));
}
if (sym == newvar_sym) {
return jl_new_struct(jl_newvarnode_type,
scm_to_julia_(car_(e),0));
}
}
jl_expr_t *ex = jl_exprn(sym, n);
// allocate a fresh args array for empty exprs passed to macros
if (eo && n == 0)
ex->args = jl_alloc_cell_1d(0);
for(i=0; i < n; i++) {
assert(iscons(e));
jl_cellset(ex->args, i, scm_to_julia_(car_(e),eo));
e = cdr_(e);
}
return (jl_value_t*)ex;
}
else {
jl_error("malformed tree");
}
}
if (iscprim(e) && cp_class((cprim_t*)ptr(e))==wchartype) {
jl_value_t *wc =
jl_box32(jl_char_type, *(int32_t*)cp_data((cprim_t*)ptr(e)));
return wc;
}
if (iscvalue(e) && cv_class((cvalue_t*)ptr(e)) == jvtype) {
return *(jl_value_t**)cv_data((cvalue_t*)ptr(e));
}
jl_error("malformed tree");
return (jl_value_t*)jl_null;
}
value_t fl_current_julia_module(value_t *args, uint32_t nargs)
{
value_t opaque = cvalue(jvtype, sizeof(void*));
*(jl_value_t**)cv_data((cvalue_t*)ptr(opaque)) = (jl_value_t*)jl_current_module;
return opaque;
}
inline int string::type()
{
return ASN1_STRING_type(ptr().get());
}
inline void string::set_data(const char* _data)
{
error::throw_error_if_not(ASN1_STRING_set(ptr().get(), _data, -1) != 0);
}
inline void string::set_data(const void* _data, size_t data_len)
{
error::throw_error_if_not(ASN1_STRING_set(ptr().get(), _data, static_cast<int>(data_len)) != 0);
}
void CSourcePython::OnEdictFreed( const edict_t *edict )
{
CALL_LISTENERS(OnEdictFreed, ptr(edict));
}
const CppObject * operator->() const { return ptr(); }
void CSourcePython::OnEntityDeleted( CBaseEntity *pEntity )
{
CALL_LISTENERS(OnEntityDeleted, ptr((CBaseEntityWrapper*) pEntity));
}
void Texture::set_pixel(const int32_t x, const int32_t y, const D3DXCOLOR& col)
{
const int32_t safe_x = clamp(x, 0, _width-1);
const int32_t safe_y = clamp(y, 0, _height-1);
*ptr(safe_x, safe_y) = col;
}
void Item_group::add_group_entry(const Group_tag &groupid, int probability)
{
std::unique_ptr<Item_spawn_data> ptr(new Single_item_creator(groupid, Single_item_creator::S_ITEM_GROUP, probability));
add_entry(ptr);
}
void t5 () {
extern char *ptr();
free(ptr()); // no-warning
}
// -----------------------------------------------------------------------------
// CSdpOriginField::InternalizeL
// Internalizes from stream
// -----------------------------------------------------------------------------
//
CSdpOriginField* CSdpOriginField::InternalizeL(
RReadStream& aStream )
{
RStringPool pool = SdpCodecStringPool::StringPoolL();
// <username>
TUint32 length = aStream.ReadUint32L();
HBufC8* userName = HBufC8::NewLC( length );
TPtr8 ptr( userName->Des() );
aStream.ReadL( ptr, length );
// <session id>
length = aStream.ReadUint32L();
HBufC8* sessionId = HBufC8::NewLC( length );
ptr.Set( sessionId->Des() );
aStream.ReadL( ptr, length );
// <version>
length = aStream.ReadUint32L();
HBufC8* version = HBufC8::NewLC( length );
ptr.Set( version->Des() );
aStream.ReadL( ptr, length );
// <network type>
length = aStream.ReadUint32L();
HBufC8* netType = HBufC8::NewLC( length );
ptr.Set( netType->Des() );
aStream.ReadL( ptr, length );
// <address type>
length = aStream.ReadUint32L();
HBufC8* addrType = HBufC8::NewLC( length );
ptr.Set( addrType->Des() );
aStream.ReadL( ptr, length );
// <address>
length = aStream.ReadUint32L();
HBufC8* address = HBufC8::NewLC( length );
TPtr8 ptr2( address->Des() );
aStream.ReadL( ptr2, length );
RStringF netTypeStr = pool.OpenFStringL( *netType );
RStringF addrTypeStr = pool.OpenFStringL( *addrType );
CleanupClosePushL( netTypeStr );
CleanupClosePushL( addrTypeStr );
CSdpOriginField* obj = CSdpOriginField::NewLC( *userName, KDummyValue,
KDummyValue, netTypeStr,
addrTypeStr, *address );
// Set the real values
obj->OriginFieldPtrs().SetSessionIdL( *sessionId );
obj->OriginFieldPtrs().SetSessionVersionL( *version );
CleanupStack::Pop( obj );
CleanupStack::Pop( 2 ); // addrTypeStr, netTypeStr
CleanupStack::PopAndDestroy( address );
CleanupStack::PopAndDestroy( addrType );
CleanupStack::PopAndDestroy( netType );
CleanupStack::PopAndDestroy( version );
CleanupStack::PopAndDestroy( sessionId );
CleanupStack::PopAndDestroy( userName );
return obj;
}
void
inline_through_me (void (*ptr)(void))
{
ptr();
}
operator CUdeviceptr()
{ return ptr(); }
// just a sanity test, the same behavior as t1()
char t2 () {
*ptr() = 'c';
return '0';
}
SmartArray<T> reverse() const { SmartArray<T> res(size()); T* dst = res.ptr(); const T* end = ptr(); const T* cursor = end + size() - 1; while(cursor >= end) *dst++ = *cursor--; return res; }
char t4 () {
char* p = ptr();
*p = 'c'; // no-warning
if (*p) return *p;
return *(char*)0; // no-warning
}
std::shared_ptr<dt::NetworkEvent> CustomNetworkEvent::Clone() const {
std::shared_ptr<dt::NetworkEvent> ptr(new CustomNetworkEvent(mData, mEnum));
return ptr;
}
//-----------------------------------------------------------------------------
// Purpose: called on
//-----------------------------------------------------------------------------
void CSourcePython::ClientPutInServer( edict_t *pEntity, char const *playername )
{
CALL_LISTENERS(OnClientPutInServer, ptr(pEntity), playername);
}
EXPORT_C TInt RLbsNetworkLocationRequests::SetNetworkLocationRequest(const TLbsNetLocMsgBase& aMessage)
{
__ASSERT_DEBUG(iNetLocRequestProperty.Handle() != NULL, User::Invariant());
TPtrC8 ptr(reinterpret_cast<const TUint8*>(&aMessage), aMessage.Size());
return (iNetLocRequestProperty.Set(ptr));
}
inline size_t string::size()
{
return ASN1_STRING_length(ptr().get());
}