C++ Address::IsBroadcast方法代码示例

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Method to add a new connection manually to a component at an
///          IP address.
///
///   \param[in] networkIP IP Address of component.
///   \param[in] jausID JAUS ID of component.
///   \param[in] port Network port to use (default is 3794).
///
///   \return True on success, false on failure.
///
////////////////////////////////////////////////////////////////////////////////////
bool JUDP::AddConnection(const CxUtils::IP4Address& networkIP,
                         const Address& jausID,
                         const unsigned short port)
{
    bool result = false;

    if(jausID.IsValid() && !jausID.IsBroadcast())
    {
        Mutex::ScopedLock lock(&mClientsMutex);
        std::map<Address, CxUtils::UdpClient*>::iterator citer;
        citer = mClients.find(jausID);
        if(citer == mClients.end())
        {
            CxUtils::UdpClient* udp = mMulticast.CreateNewDestination(networkIP, port);
            if(udp)
            {
                mClients[jausID] = udp;
                mUpdateTimes[jausID] = Time::GetUtcTimeMs();
                mPermanentConnections[jausID] = true;
                udp = NULL;
                result = true;
            }
            else
            {
                if(mDebugMessagesFlag)
                {
                    Mutex::ScopedLock lock(&mDebugMessagesMutex);
                    std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() << "] - New Connection Made to " << jausID << " at IP:" << networkIP.mString << std::endl;
                }
            }
        }
    }

    return result;
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \return ID of the controlling component.
///
////////////////////////////////////////////////////////////////////////////////////
void AccessControl::SetControllerID(const Address& id)
{
    if(id.IsValid() && !id.IsBroadcast())
    {
        Mutex::ScopedLock lock(&mControlMutex);
        mControllerID = id;
    }
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Set the ID of controlling component.
///
///   \param[in] ID of the controlling component.
///
////////////////////////////////////////////////////////////////////////////////////
void AccessControl::SetControllerID(const Address& id)
{
    if(id.IsValid() && !id.IsBroadcast())
    {
        WriteLock wLock(mControlMutex);
        mControllerID = id;
    }
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Sets the source ID of the message.
///
///   \param[in] src Source ID.  Must be valid and non-broadcast.
///
///   \return OK on success, FAILURE on error.
///
////////////////////////////////////////////////////////////////////////////////////
int Message::SetSourceID(const Address& src)
{
    if(src.IsValid() && !src.IsBroadcast())
    {
        mSourceID = src;
        return OK;
    }
    return FAILURE;
}

////////////////////////////////////////////////////////////////////////////////////
///
///   \brief Initializes the Transport Service based on configuration values
///          set.
///
///   \param[in] componentID ID of the component using the Transport Service.
///
///   \return True on success, false on failure.
///
////////////////////////////////////////////////////////////////////////////////////
bool JUDP::Initialize(const Address& componentID)
{
    if(componentID.IsValid() == false || componentID.IsBroadcast())
    {
        return false;
    }
    
    Shutdown();
    
    // Save ID.
    mComponentID = componentID;
    CxUtils::IP4Address::List hostnames;
    CxUtils::IP4Address::List::iterator eth0;
    CxUtils::Socket::GetHostAddresses(hostnames);
    if(hostnames.size() == 0 && mDebugMessagesFlag)
    {
        Mutex::ScopedLock lock(&mDebugMessagesMutex);
        std::cout << "[JUDP-" << mComponentID.ToString() << "] - No Network Interface Found.\n";
    }
    unsigned int count = 0;
    for(eth0 = hostnames.begin();
        eth0 != hostnames.end();
        eth0++, count++)
    {
        // Use any or specified interface.
        if(mHostIP.mString == "0.0.0.0" ||
           mHostIP.mString == "127.0.0.1" ||
           mHostIP.mString.empty() ||
           mHostIP == *eth0)
        {
            // Initialize UDP receiving.
            if(mInput.InitializeMulticastSocket(Port, mMulticastIP, true))
            {
                mMulticast.SetNetworkInterface(*eth0);
                if(mMulticast.InitializeMulticastSocket(mMulticastIP, Port, mTimeToLive, mUseBroadcastingFlag, 0))
                {
                    SetComponentID(componentID);
                    
                    mPrimaryThread.CreateThread(JUDP::ReceiveThread, this);
                    CxUtils::SleepMs(250);
                    mSecondaryThread.CreateThread(JUDP::ReceiveThread, this);
                    // Set thread names.
                    mPrimaryThread.SetThreadName(std::string("JUDP 1 ") + componentID.ToString());
                    mSecondaryThread.SetThreadName(std::string("JUDP 2 ") + componentID.ToString());
                    return true;
                }
            }
            /*
            mPrimarySocket.SetNetworkInterface(mHostIP);
            mSecondarySocket.SetNetworkInterface(mHostIP);
            // Try initialize on 3794 first, but accept any available.
            if(mPrimarySocket.InitializeMulticastSocket(mMulticastIP, Port, mTimeToLive, mUseBroadcastingFlag, Port, true) &&
               mSecondarySocket.InitializeMulticastSocket(mMulticastIP, Port, mTimeToLive, mUseBroadcastingFlag, 0, false))
            {
                    SetComponentID(componentID);
                    mPrimaryThread.CreateThread(JUDP::PrimaryThread, this);
                    std::string threadName = std::string("JUDP 1 ") + componentID.ToString();
                    mPrimaryThread.SetThreadName(threadName);

                    // Have a thread to discover new UDP clients that are transmitting.
                    mSecondaryThread.CreateThread(JUDP::SecondaryThread, this);
                    threadName = std::string("JUDP 2 ") + componentID.ToString();
                    mSecondaryThread.SetThreadName(threadName);

                    return true;
            }
            */
        }
    }
    
    Shutdown();

    return false;
}