function create_message_type($name, array $copyArgs, array $swapArgs, $serializable = false, $copyable = false)
{
$allArgs = array_merge($copyArgs, $swapArgs);
// Create the constructor parameter string. We have to do this specially
// because copy constructed parameters can be passed as const references
// while swapped members must be passed as plain references.
$constructor_array = [];
foreach ($copyArgs as $n => $t) {
if (should_reference($t)) {
array_push($constructor_array, "{$t} & {$n}");
} else {
array_push($constructor_array, "{$t} {$n}");
}
}
foreach ($swapArgs as $n => $t) {
array_push($constructor_array, "{$t} & {$n}");
}
$constructor_params = implode(CSL_SEP, $constructor_array);
// The factory function takes an EventProcessor as its first input, so
// put together the parameters for that.
$factory_array = ['EventProcessor & __dest'];
$factory_array = array_merge($factory_array, $constructor_array);
$factory_params = implode(CSL_SEP, $factory_array);
$allArgs = array_merge($copyArgs, $swapArgs);
// Escape from PHP to start outputing the C++ code.
?>
class <?php
echo $name;
?>
: public Message {
public:
// members
<?php
foreach ($allArgs as $n => $t) {
?>
<?php
echo $t;
?>
<?php
echo $n;
?>
;
<?php
}
?>
private:
// constructor
<?php
echo $name;
?>
( <?php
echo $constructor_params;
?>
) :
Message()
// Copy constructed members
<?php
foreach ($copyArgs as $n => $t) {
?>
, <?php
echo $n;
?>
( <?php
echo $n;
?>
)
<?php
}
?>
{
// swapped members
<?php
foreach ($swapArgs as $n => $t) {
?>
(this-><?php
echo $n;
?>
).swap(<?php
echo $n;
?>
);
<?php
}
?>
}
<?php
if (count($constructor_array) > 0) {
?>
// Default constructor
<?php
echo $name;
?>
( void ) : Message() { }
<?php
}
?>
<?php
if ($copyable) {
?>
<?php
echo $name;
?>
( <?php
echo $name;
?>
& other ) {
<?php
foreach ($copyArgs as $n => $t) {
?>
<?php
echo $n;
?>
= other.<?php
echo $n;
?>
;
<?php
}
foreach ($swapArgs as $n => $t) {
?>
<?php
echo $n;
?>
.copy(other.<?php
echo $n;
?>
);
<?php
}
?>
}
<?php
}
// if copyable
?>
public:
// Destructor
virtual ~<?php
echo $name;
?>
() {}
// type
static constexpr off_t type = <?php
echo hash_name($name);
?>
;
virtual off_t Type(void) const OVERRIDE_SPEC { return <?php
echo hash_name($name);
?>
; }
virtual const char * TypeName(void) const OVERRIDE_SPEC { return "<?php
echo $name;
?>
"; }
// To/From Json
<?php
if ($serializable) {
?>
virtual void ToJson( Json::Value & dest ) const OVERRIDE_SPEC {
dest = Json::Value(Json::objectValue);
<?php
foreach ($copyArgs as $n => $t) {
?>
::ToJson(<?php
echo $n;
?>
, dest["<?php
echo $n;
?>
"]);
<?php
}
foreach ($swapArgs as $n => $t) {
?>
::ToJson(<?php
echo $n;
?>
, dest["<?php
echo $n;
?>
"]);
<?php
}
?>
}
virtual void FromJson ( const Json::Value & src ) OVERRIDE_SPEC {
if( ! src.isObject() ) {
throw new std::invalid_argument("Tried to construct <?php
echo $name;
?>
message from non-object JSON");
}
<?php
foreach ($allArgs as $n => $t) {
?>
if( ! src.isMember("<?php
echo $n;
?>
") )
throw new std::invalid_argument("JSON for message <?php
echo $name;
?>
has no member for attribute <?php
echo $n;
?>
");
::FromJson(src["<?php
echo $n;
?>
"], <?php
echo $n;
?>
);
<?php
}
?>
}
<?php
} else {
?>
virtual void ToJson( Json::Value & dest ) const OVERRIDE_SPEC {
FATAL("Message type <?php
echo $name;
?>
is not serializable.");
}
virtual void FromJson ( const Json::Value & src ) OVERRIDE_SPEC {
FATAL("Message type <?php
echo $name;
?>
is not serializable.");
}
<?php
}
// it not serializable
?>
// Constructor from JSON
// This constructor has a bizarre signature on purpose as not to conflict
// with messages that contain exactly 1 JSON value as their payload.
// It is our hope that no sane individual would store 3 void pointers in a
// message.
<?php
echo $name;
?>
( const Json::Value & src, void * dummy1, void * dummy2, void * dummy3 ) {
FromJson(src);
}
// friend delcarations
<?php
if (isset($message_debug_class)) {
?>
friend class <?php
echo $message_debug_class;
?>
;
<?php
}
?>
friend void <?php
echo $name;
?>
_Factory( <?php
echo $factory_params;
?>
);
// Factory function to build a <?php
echo $name;
?>
object
static void Factory( <?php
echo $factory_params;
?>
) {
Message * __msg = (Message *) new <?php
echo $name;
?>
( <?php
echo args($allArgs);
?>
);
__dest.ProcessMessage(*__msg);
}
<?php
if ($copyable) {
?>
// Factory function to send a copy of the message
static void Factory( EventProcessor & dest, <?php
echo $name;
?>
& msg ) {
Message * __msg = (Message *) new <?php
echo $name;
?>
( msg );
dest.ProcessMessage(*__msg);
}
<?php
}
// if copyable
?>
}; // End of class <?php
echo $name;
?>
inline
void ToJson( const <?php
echo $name;
?>
& src, Json::Value & dest ) {
src.ToJson(dest);
}
inline
void FromJson( const Json::Value & src, <?php
echo $name;
?>
& dest ) {
dest.FromJson(src);
}
// Factory function to build <?php
echo $name;
?>
objects
inline
void <?php
echo $name;
?>
_Factory( <?php
echo $factory_params;
?>
) {
Message * __msg = (Message *) new <?php
echo $name;
?>
( <?php
echo args($allArgs);
?>
);
__dest.ProcessMessage(*__msg);
}
<?php
}
$stmt->execute();
$stmt->bindColumn($db_columnPass, $realPass);
$stmt->bindColumn('scheme_class', $scheme_class);
$stmt->fetch();
$realPass = substr($realPass, 22, 64);
if ($scheme_class === 'XenForo_Authentication_Core') {
$salt = substr($salt, 105, 64);
} else {
$salt = false;
}
} else {
die(Security::encrypt(json_encode(array('error' => true, 'code' => STATUS_INTERNAL_ERROR, 'text' => 'Bad hash!')), $key1));
}
}
}
$checkPass = hash_name($crypt, $realPass, $postPass, @$salt);
if ($useantibrut) {
$ip = getenv('REMOTE_ADDR');
$time = time();
$bantime = $time + 10;
$stmt = $db->prepare("Select sip,time From sip Where sip='{$ip}' And time>'{$time}'");
$stmt->execute();
$row = $stmt->fetch(PDO::FETCH_ASSOC);
$real = $row['sip'];
if ($ip == $real) {
$stmt = $db->prepare("DELETE FROM sip WHERE time < '{$time}';");
$stmt->execute();
exit(Security::encrypt(json_encode(array("error" => true, "code" => STATUS_BAD_LOGIN, "text" => "Timeout")), $key1));
}
if ($login !== $realUser) {
$stmt = $db->prepare("INSERT INTO sip (sip, time)VALUES ('{$ip}', '{$bantime}')");
public function expand()
{
// Alias members so I don't go crazy trying to add $this-> to all of
// them. I didn't know that you HAVE to have the $this->, even within
// a class's method.
$name =& $this->name;
$parent =& $this->parent;
$copyArgs =& $this->copyArgs;
$swapArgs =& $this->swapArgs;
$copyable =& $this->copyable;
$serializable =& $this->serializable;
$sep_deserial = $this->sep_deserial;
$constructorArgs =& $this->constructorArgs;
$myArgs =& $this->myArgs;
$allCopy =& $this->allCopy;
$allSwap =& $this->allSwap;
?>
// forward definition
class <?php
echo $name;
?>
;
// Defining the implementation class first.
class <?php
echo $name;
?>
Imp : public <?php
echo $parent->name;
?>
Imp {
protected:
// members
<?php
foreach ($myArgs as $n => $t) {
?>
<?php
echo $t;
?>
<?php
echo $n;
?>
;
<?php
}
?>
public:
// Constructor
<?php
echo $name;
?>
Imp( <?php
echo $this->get_constructor_params();
?>
) :
<?php
echo $parent->name;
?>
Imp( <?php
echo args($parent->constructorArgs);
?>
)
// copy constructed members
<?php
foreach ($copyArgs as $n => $t) {
?>
, <?php
echo $n;
?>
( <?php
echo $n;
?>
)
<?php
}
?>
{
<?php
foreach ($swapArgs as $n => $t) {
?>
this-><?php
echo $n;
?>
.swap(<?php
echo $n;
?>
);
<?php
}
?>
}
<?php
if (count($constructorArgs) > 0) {
?>
// Default constructor
<?php
echo $name;
?>
Imp() : <?php
echo $parent->name;
?>
Imp() { }
<?php
}
?>
<?php
if ($copyable) {
?>
protected:
// Protected copy constructor used for Clone
<?php
echo $name;
?>
Imp( <?php
echo $name;
?>
Imp& fromMe ) : <?php
echo $parent->name;
?>
Imp( fromMe ) {
// Copy my stuff
// Copy-constructed stuff first
<?php
foreach ($copyArgs as $n => $t) {
?>
this-><?php
echo $n;
?>
= fromMe.<?php
echo $n;
?>
;
<?php
}
?>
// Now swapped stuff (with explicit copies)
<?php
foreach ($swapArgs as $n => $t) {
?>
this-><?php
echo $n;
?>
.copy( fromMe.<?php
echo $n;
?>
);
<?php
}
?>
}
public:
// Clone method. Can create a copy of the object.
virtual DataImp* Clone() OVERRIDE_SPEC {
// Use copy constructor to create a new object that copies me
return new <?php
echo $name;
?>
Imp( *this );
}
<?php
}
?>
// destructor
virtual ~<?php
echo $name;
?>
Imp() {}
// type
static constexpr off_t _type_ = <?php
echo hash_name($name);
?>
;
virtual const off_t Type(void) const OVERRIDE_SPEC {
return <?php
echo hash_name($name);
?>
;
}
virtual const char * TypeName(void) const OVERRIDE_SPEC {
return "<?php
echo $name;
?>
";
}
<?php
if ($serializable) {
?>
virtual void toJson( Json::Value & dest ) const OVERRIDE_SPEC {
dest = Json::Value(Json::objectValue);
// Serialize parent
<?php
echo $parent->name;
?>
Imp::toJson(dest["|parent|"]);
dest["|type|"] = (Json::Int64) _type_;
// Store members
<?php
foreach ($myArgs as $n => $t) {
?>
ToJson(<?php
echo $n;
?>
, dest["<?php
echo $n;
?>
"]);
<?php
}
?>
}
virtual void fromJson( const Json::Value & src ) OVERRIDE_SPEC {
// Deserialize parent
<?php
echo $parent->name;
?>
Imp::fromJson(src["|parent|"]);
off_t jType = (off_t) src["|type|"].asInt64();
FATALIF(jType != _type_, "Attempting to deserialize <?php
echo $name;
?>
from JSON for different type "
"with hash %llx", (unsigned long long) jType);
// Deserialize members
<?php
foreach ($myArgs as $n => $t) {
?>
FromJson(src["<?php
echo $n;
?>
"], <?php
echo $n;
?>
);
<?php
}
?>
}
<?php
} else {
?>
virtual void toJson( Json::Value & dest ) const OVERRIDE_SPEC {
FATAL("Data type <?php
echo $name;
?>
is not serializable.");
}
virtual void fromJson ( const Json::Value & src ) OVERRIDE_SPEC {
FATAL("Data type <?php
echo $name;
?>
is not serializable.");
}
<?php
}
// it not serializable
?>
friend class <?php
echo $name;
?>
;
}; // End of class <?php
echo $name;
?>
Imp
// Front end class <?php
echo $name;
?>
class <?php
echo $name;
?>
: public <?php
echo $parent->name;
?>
{
public:
// the type
static const off_t type = <?php
echo hash_name($name);
?>
;
// Constructor
<?php
echo $name;
?>
( <?php
echo $this->get_constructor_params();
?>
) {
this->data = new <?php
echo $name;
?>
Imp( <?php
echo args($constructorArgs);
?>
);
}
<?php
if (count($constructorArgs) > 0) {
?>
// Default constructor
<?php
echo $name;
?>
( void ) : <?php
echo $parent->name;
?>
( ) { }
<?php
}
?>
<?php
if ($copyable) {
?>
// Copy constructor
<?php
echo $name;
?>
( <?php
echo $name;
?>
& o ) {
copy(o);
}
// Copy assignment
<?php
echo $name;
?>
& operator = (<?php
echo $name;
?>
& o) {
copy(o);
return *this;
}
<?php
}
?>
// Move constructor
<?php
echo $name;
?>
( <?php
echo $name;
?>
&& o ): <?php
echo $parent->name;
?>
()
{
swap(o);
}
// Access methods for all new data
<?php
foreach ($myArgs as $n => $t) {
?>
<?php
echo $t;
?>
& get_<?php
echo $n;
?>
() {
<?php
echo $name;
?>
Imp * myData = dynamic_cast< <?php
echo $name;
?>
Imp* >( this->data );
FATALIF( myData == nullptr, "Trying to get member <?php
echo $n;
?>
of an invalid or wrong type <?php
echo $name;
?>
!");
return myData-><?php
echo $n;
?>
;
}
<?php
}
?>
virtual void toJson( Json::Value & dest ) const override {
<?php
echo $name;
?>
Imp * myData = dynamic_cast< <?php
echo $name;
?>
Imp* >( this->data );
if( myData != nullptr )
myData->toJson(dest);
}
virtual void fromJson( const Json::Value & src ) override {
if( this->data == nullptr ) {
<?php
echo $name;
?>
Imp * myData = new <?php
echo $name;
?>
Imp;
myData->fromJson(src);
this->data = myData;
}
else {
<?php
echo $name;
?>
Imp * myData = dynamic_cast< <?php
echo $name;
?>
Imp* >( this->data );
FATALIF(myData == nullptr, "Trying to deserialize into invalid <?php
$name;
?>
object!");
myData->fromJson(src);
}
}
}; // End of class <?php
echo $name;
?>
inline
void ToJson( const <?php
echo $name;
?>
& src, Json::Value & dest ) {
src.toJson(dest);
}
<?php
if (!$sep_deserial) {
?>
inline
void FromJson( const Json::Value & src, <?php
echo $name;
?>
& dest ) {
dest.fromJson(src);
}
<?php
}
// if not separate deserializer
?>
<?php
}
