C++ OTTransactionType类代码示例

// OTAccount, OTTransaction, OTItem, and OTLedger are all derived from
// this class (OTTransactionType). Therefore they can all quickly identify
// whether one of the other components belongs to the same account, using
// this method.
//
bool OTTransactionType::IsSameAccount(const OTTransactionType& rhs) const
{
    if ((GetNymID() != rhs.GetNymID()) ||
        (GetRealAccountID() != rhs.GetRealAccountID()) ||
        (GetRealNotaryID() != rhs.GetRealNotaryID()))
        return false;
    return true;
}

// Allows you to compare any OTTransaction or OTItem to any other OTTransaction or OTItem,
// and see if they share the same origin number.
//
// Let's say Alice sends a transfer #100 to Bob.
// Then Bob receives a pending in his inbox, #800, which is in reference to #100.
// Then Bob accepts the pending with processInbox #45, which is in reference to #800.
// Then Alice receives a transferReceipt #64, which is in reference to #45.
// Then Alice accepts the transferReceipt with processInbox #91, in reference to #64.
//
// ALL OF THOSE transactions and receipts will have origin #100 attached to them.
//
bool OTTransactionType::VerifyNumberOfOrigin(OTTransactionType & compareTo)
{
    // Have to use the function here, NOT the internal variable.
    // (Because subclasses may override the function.)
    //
    return (this->GetNumberOfOrigin() == compareTo.GetNumberOfOrigin());
}

void OTTransactionType::SetNumberOfOrigin(OTTransactionType & setFrom)
{
	m_lNumberOfOrigin = setFrom.GetNumberOfOrigin();
}

// static -- class factory.
//
OTTransactionType * OTTransactionType::TransactionFactory(OTString strInput)
{
    const char * szFunc = "OTTransactionType::TransactionFactory";
    // --------------------------------------------------------------------
    OTString   strContract, strFirstLine; // output for the below function.
    const bool bProcessed = OTContract::DearmorAndTrim(strInput, strContract, strFirstLine);
    // --------------------------------------------------------------------
    if (bProcessed)
    {
        OTTransactionType * pContract = NULL;
        
        if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION-----"))  // this string is 34 chars long.
        {	pContract = new OTTransaction();	OT_ASSERT(NULL != pContract); }
        
        else if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION ITEM-----"))  // this string is 39 chars long.
        {	pContract = new OTItem();           OT_ASSERT(NULL != pContract); }
        
        else if (strFirstLine.Contains("-----BEGIN SIGNED LEDGER-----"))  // this string is 29 chars long.
        {	pContract = new OTLedger();			OT_ASSERT(NULL != pContract); }
        
        else if (strFirstLine.Contains("-----BEGIN SIGNED ACCOUNT-----"))  // this string is 30 chars long.
        {	pContract = new OTAccount();		OT_ASSERT(NULL != pContract); }
        
        // ----------------------------------------------
        // The string didn't match any of the options in the factory.
        //
        // The string didn't match any of the options in the factory.
        if (NULL == pContract)
        {
            OTLog::vOutput(0, "%s: Object type not yet supported by class factory: %s\n",
                           szFunc, strFirstLine.Get());
            return NULL;
        }
        
        // This causes pItem to load ASSUMING that the PurportedAcctID and PurportedServerID are correct.
        // The object is still expected to be internally consistent with its sub-items, regarding those IDs,
        // but the big difference is that it will SET the Real Acct and Real Server IDs based on the purported
        // values. This way you can load a transaction without knowing the account in advance.
        //
        pContract->m_bLoadSecurely = false;
        
        // Does the contract successfully load from the string passed in?
        if (pContract->LoadContractFromString(strContract))
        {
            // NOTE: this already happens in OTTransaction::ProcessXMLNode and OTLedger::ProcessXMLNode.
            // Specifically, it happens when m_bLoadSecurely is set to false.
            //
//          pContract->SetRealServerID(pItem->GetPurportedServerID());
//          pContract->SetRealAccountID(pItem->GetPurportedAccountID());
//
            return pContract;
        }
        else
        {
            OTLog::vOutput(0, "%s: Failed loading contract from string (first line): %s\n",
                           szFunc, strFirstLine.Get());
            delete pContract;
            pContract = NULL;
        }
    }
    // --------------------------------------------------------------------    
    return NULL;
}

// static -- class factory.
//
OTTransactionType * OTTransactionType::TransactionFactory(const OTString & strInput)
{
	static char		buf[45] = "";
    
	OTTransactionType *	pItem = NULL;
	
	if (!strInput.Exists())
		return NULL;
    
    // --------------------------------------------------------------------
	//
    // To support legacy data, we check here to see if it's armored or not.
    // If it's not, we support it. But if it IS, we ALSO support it (we de-armor it here.)
    //
    bool bArmoredAndALSOescaped = false;    // "- -----BEGIN OT ARMORED"
    bool bArmoredButNOTescaped  = false;    // "-----BEGIN OT ARMORED"
    
    if (strInput.Contains(OT_BEGIN_ARMORED_escaped)) // check this one first...
    {
        bArmoredAndALSOescaped = true;
        
        OTLog::Error("OTTransactionType::TransactionFactory: Armored and escaped value passed in, "
                     "but escaped are forbidden here. (Returning NULL.)\n");
		return NULL;
    }
    else if (strInput.Contains(OT_BEGIN_ARMORED))
    {
        bArmoredButNOTescaped = true;
    }
    // ----------------------------------------
    const bool bArmored = (bArmoredAndALSOescaped || bArmoredButNOTescaped);
    // ----------------------------------------
    
    // Whether the string is armored or not, (-----BEGIN OT ARMORED)
    // either way, we'll end up with the decoded version in this variable:
    //
    std::string str_Trim;
    
    // ------------------------------------------------
    if (bArmored) // it's armored, we have to decode it first.
    {
        OTASCIIArmor ascTemp;
        OTString strInputTemp(strInput);
        
        if (false == (ascTemp.LoadFromString(strInputTemp, 
                                             bArmoredAndALSOescaped, // if it IS escaped or not, this variable will be true or false to show it.
                                             // The below szOverride sub-string determines where the content starts, when loading.
                                             OT_BEGIN_ARMORED)))     // Default is:       "-----BEGIN" 
                                                                     // We're doing this: "-----BEGIN OT ARMORED" (Should worked for escaped as well, here.)
        {
            OTLog::vError("OTTransactionType::TransactionFactory: Error "
                          "loading string contents from ascii-armored encoding. Contents: \n%s\n", 
                          strInput.Get());
            return NULL;
        }
        else // success loading the actual contents out of the ascii-armored version.
        {
            OTString strTemp(ascTemp); // <=== ascii-decoded here.
            std::string str_temp(strTemp.Get(), strTemp.GetLength());
            str_Trim = OTString::trim(str_temp); // This is the std::string for the trim process.
        } 
    }
    else
    {
        std::string str_temp(strInput.Get(), strInput.GetLength());
        str_Trim = OTString::trim(str_temp); // This is the std::string for the trim process. (Wasn't armored, so here we use it as passed in.)
    }
    // ------------------------------------------------
    
    // At this point, str_Trim contains the actual contents, whether they
    // were originally ascii-armored OR NOT. (And they are also now trimmed, either way.)
    // ------------------------------------------
    
    OTString strContract(str_Trim.c_str());
	
	strContract.reset(); // for sgets
	buf[0] = 0; // probably unnecessary.
	bool bGotLine = strContract.sgets(buf, 40);
    
	if (!bGotLine)
		return NULL;
	
	OTString strFirstLine(buf);
	strContract.reset(); // set the "file" pointer within this string back to index 0.
	
	// Now I feel pretty safe -- the string I'm examining is within
	// the first 45 characters of the beginning of the contract, and
	// it will NOT contain the escape "- " sequence. From there, if
	// it contains the proper sequence, I will instantiate that type.
	if (!strFirstLine.Exists() || strFirstLine.Contains("- -"))
		return NULL;
    
	if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION-----"))  // this string is 34 chars long.
	{	pItem = new OTTransaction();		OT_ASSERT(NULL != pItem); }
	
	else if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION ITEM-----"))  // this string is 39 chars long.
	{	pItem = new OTItem();	OT_ASSERT(NULL != pItem); }
	
//.........这里部分代码省略.........

OTTransactionType* OTTransactionType::TransactionFactory(String strInput)
{
    String strContract, strFirstLine; // output for the below function.
    const bool bProcessed =
        Contract::DearmorAndTrim(strInput, strContract, strFirstLine);

    if (bProcessed) {
        OTTransactionType* pContract = nullptr;

        if (strFirstLine.Contains(
                "-----BEGIN SIGNED TRANSACTION-----")) // this string is 34
                                                       // chars long.
        {
            pContract = new OTTransaction();
            OT_ASSERT(nullptr != pContract);
        }
        else if (strFirstLine.Contains(
                       "-----BEGIN SIGNED TRANSACTION ITEM-----")) // this
                                                                   // string is
                                                                   // 39 chars
                                                                   // long.
        {
            pContract = new Item();
            OT_ASSERT(nullptr != pContract);
        }
        else if (strFirstLine.Contains(
                       "-----BEGIN SIGNED LEDGER-----")) // this string is 29
                                                         // chars long.
        {
            pContract = new Ledger();
            OT_ASSERT(nullptr != pContract);
        }
        else if (strFirstLine.Contains(
                       "-----BEGIN SIGNED ACCOUNT-----")) // this string is 30
                                                          // chars long.
        {
            pContract = new Account();
            OT_ASSERT(nullptr != pContract);
        }

        // The string didn't match any of the options in the factory.
        //

        const char* szFunc = "OTTransactionType::TransactionFactory";
        // The string didn't match any of the options in the factory.
        if (nullptr == pContract) {
            otOut << szFunc
                  << ": Object type not yet supported by class factory: "
                  << strFirstLine << "\n";
            return nullptr;
        }

        // This causes pItem to load ASSUMING that the PurportedAcctID and
        // PurportedNotaryID are correct.
        // The object is still expected to be internally consistent with its
        // sub-items, regarding those IDs,
        // but the big difference is that it will SET the Real Acct and Real
        // Notary IDs based on the purported
        // values. This way you can load a transaction without knowing the
        // account in advance.
        //
        pContract->SetLoadInsecure();

        // Does the contract successfully load from the string passed in?
        if (pContract->LoadContractFromString(strContract)) {
            // NOTE: this already happens in OTTransaction::ProcessXMLNode and
            // OTLedger::ProcessXMLNode.
            // Specifically, it happens when m_bLoadSecurely is set to false.
            //
            //          pContract->SetRealNotaryID(pItem->GetPurportedNotaryID());
            //          pContract->SetRealAccountID(pItem->GetPurportedAccountID());
            //
            return pContract;
        }
        else {
            otOut << szFunc
                  << ": Failed loading contract from string (first line): "
                  << strFirstLine << "\n";
            delete pContract;
            pContract = nullptr;
        }
    }

    return nullptr;
}