Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-04-08 06:32:35 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor Agent member variables

Browse source
This commit is contained in:
Stephen Birarda 2013-05-15 14:12:21 -07:00
parent 2c242a7704
commit 48b57c92bd
6 changed files with 71 additions and 116 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
audio-mixer/src/main.cpp
View file

@ -114,10 +114,10 @@ int main(int argc, const char* argv[]) {
if (agentBuffer->getEndOfLastWrite()) {
if (!agentBuffer->isStarted()
&& agentBuffer->diffLastWriteNextOutput() <= BUFFER_LENGTH_SAMPLES_PER_CHANNEL + JITTER_BUFFER_SAMPLES) {
printf("Held back buffer for agent with ID %d.\n", agent->getAgentId());
printf("Held back buffer for agent with ID %d.\n", agent->getAgentID());
agentBuffer->setShouldBeAddedToMix(false);
} else if (agentBuffer->diffLastWriteNextOutput() < BUFFER_LENGTH_SAMPLES_PER_CHANNEL) {
printf("Buffer from agent with ID %d starved.\n", agent->getAgentId());
printf("Buffer from agent with ID %d starved.\n", agent->getAgentID());
agentBuffer->setStarted(false);
agentBuffer->setShouldBeAddedToMix(false);
} else {

2
avatar-mixer/src/main.cpp
View file

@ -37,7 +37,7 @@
const int AVATAR_LISTEN_PORT = 55444;
unsigned char *addAgentToBroadcastPacket(unsigned char *currentPosition, Agent *agentToAdd) {
currentPosition += packAgentId(currentPosition, agentToAdd->getAgentId());
currentPosition += packAgentId(currentPosition, agentToAdd->getAgentID());
AvatarData *agentData = (AvatarData *)agentToAdd->getLinkedData();
currentPosition += agentData->getBroadcastData(currentPosition);

4
domain-server/src/main.cpp
View file

@ -50,7 +50,7 @@ int lastActiveCount = 0;
unsigned char* addAgentToBroadcastPacket(unsigned char* currentPosition, Agent* agentToAdd) {
*currentPosition++ = agentToAdd->getType();
currentPosition += packAgentId(currentPosition, agentToAdd->getAgentId());
currentPosition += packAgentId(currentPosition, agentToAdd->getAgentID());
currentPosition += packSocket(currentPosition, agentToAdd->getPublicSocket());
currentPosition += packSocket(currentPosition, agentToAdd->getLocalSocket());
@ -149,7 +149,7 @@ int main(int argc, const char * argv[])
agent->setLastHeardMicrostamp(timeNow);
// grab the ID for this agent so we can send it back with the packet
packetAgentID = agent->getAgentId();
packetAgentID = agent->getAgentID();
if (packetData[0] == PACKET_HEADER_DOMAIN_RFD
&& memchr(SOLO_AGENT_TYPES, agentType, sizeof(SOLO_AGENT_TYPES))) {

142
libraries/shared/src/Agent.cpp
View file

@ -32,69 +32,67 @@ int packAgentId(unsigned char *packStore, uint16_t agentId) {
return sizeof(uint16_t);
}
Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentId) :
Agent::Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentID) :
_isAlive(true)
{
if (agentPublicSocket != NULL) {
publicSocket = new sockaddr;
memcpy(publicSocket, agentPublicSocket, sizeof(sockaddr));
if (agentPublicSocket) {
_publicSocket = new sockaddr;
memcpy(_publicSocket, agentPublicSocket, sizeof(sockaddr));
} else {
publicSocket = NULL;
_publicSocket = NULL;
}
if (agentLocalSocket != NULL) {
localSocket = new sockaddr;
memcpy(localSocket, agentLocalSocket, sizeof(sockaddr));
if (agentLocalSocket) {
_localSocket = new sockaddr;
memcpy(_localSocket, agentLocalSocket, sizeof(sockaddr));
} else {
localSocket = NULL;
_localSocket = NULL;
}
type = agentType;
agentId = thisAgentId;
_type = agentType;
_agentID = thisAgentID;
_wakeMicrostamp = usecTimestampNow();
_lastHeardMicrostamp = usecTimestampNow();
activeSocket = NULL;
linkedData = NULL;
_activeSocket = NULL;
_linkedData = NULL;
_bytesReceivedMovingAverage = NULL;
}
Agent::Agent(const Agent &otherAgent) {
_isAlive = otherAgent._isAlive;
if (otherAgent.publicSocket != NULL) {
publicSocket = new sockaddr;
memcpy(publicSocket, otherAgent.publicSocket, sizeof(sockaddr));
if (otherAgent._publicSocket) {
_publicSocket = new sockaddr(*otherAgent._localSocket);
} else {
publicSocket = NULL;
_publicSocket = NULL;
}
if (otherAgent.localSocket != NULL) {
localSocket = new sockaddr;
memcpy(localSocket, otherAgent.localSocket, sizeof(sockaddr));
if (otherAgent._localSocket) {
_localSocket = new sockaddr(*otherAgent._localSocket);
} else {
localSocket = NULL;
_localSocket = NULL;
}
agentId = otherAgent.agentId;
_agentID = otherAgent._agentID;
if (otherAgent.activeSocket == otherAgent.publicSocket) {
activeSocket = publicSocket;
} else if (otherAgent.activeSocket == otherAgent.localSocket) {
activeSocket = localSocket;
if (otherAgent._activeSocket == otherAgent._publicSocket) {
_activeSocket = _publicSocket;
} else if (otherAgent._activeSocket == otherAgent._localSocket) {
_activeSocket = _localSocket;
} else {
activeSocket = NULL;
_activeSocket = NULL;
}
_wakeMicrostamp = otherAgent._wakeMicrostamp;
_lastHeardMicrostamp = otherAgent._lastHeardMicrostamp;
type = otherAgent.type;
_type = otherAgent._type;
if (otherAgent.linkedData != NULL) {
linkedData = otherAgent.linkedData->clone();
if (otherAgent._linkedData) {
_linkedData = otherAgent._linkedData->clone();
} else {
linkedData = NULL;
_linkedData = NULL;
}
if (otherAgent._bytesReceivedMovingAverage != NULL) {
@ -114,28 +112,24 @@ void Agent::swap(Agent &first, Agent &second) {
using std::swap;
swap(first._isAlive, second._isAlive);
swap(first.publicSocket, second.publicSocket);
swap(first.localSocket, second.localSocket);
swap(first.activeSocket, second.activeSocket);
swap(first.type, second.type);
swap(first.linkedData, second.linkedData);
swap(first.agentId, second.agentId);
swap(first._publicSocket, second._publicSocket);
swap(first._localSocket, second._localSocket);
swap(first._activeSocket, second._activeSocket);
swap(first._type, second._type);
swap(first._linkedData, second._linkedData);
swap(first._agentID, second._agentID);
swap(first._wakeMicrostamp, second._wakeMicrostamp);
swap(first._lastHeardMicrostamp, second._lastHeardMicrostamp);
swap(first._bytesReceivedMovingAverage, second._bytesReceivedMovingAverage);
}
Agent::~Agent() {
delete publicSocket;
delete localSocket;
delete linkedData;
delete _publicSocket;
delete _localSocket;
delete _linkedData;
delete _bytesReceivedMovingAverage;
}
char Agent::getType() const {
return type;
}
// Names of Agent Types
const char* AGENT_TYPE_NAME_DOMAIN = "Domain";
const char* AGENT_TYPE_NAME_VOXEL = "Voxel Server";
@ -146,7 +140,7 @@ const char* AGENT_TYPE_NAME_AUDIO_INJECTOR = "Audio Injector";
const char* AGENT_TYPE_NAME_UNKNOWN = "Unknown";
const char* Agent::getTypeName() const {
switch (this->type) {
switch (this->_type) {
case AGENT_TYPE_DOMAIN:
return AGENT_TYPE_NAME_DOMAIN;
case AGENT_TYPE_VOXEL:
@ -164,63 +158,23 @@ const char* Agent::getTypeName() const {
}
}
void Agent::setType(char newType) {
type = newType;
}
uint16_t Agent::getAgentId() {
return agentId;
}
void Agent::setAgentId(uint16_t thisAgentId) {
agentId = thisAgentId;
}
sockaddr* Agent::getPublicSocket() {
return publicSocket;
}
void Agent::setPublicSocket(sockaddr *newSocket) {
publicSocket = newSocket;
}
sockaddr* Agent::getLocalSocket() {
return localSocket;
}
void Agent::setLocalSocket(sockaddr *newSocket) {
publicSocket = newSocket;
}
sockaddr* Agent::getActiveSocket() {
return activeSocket;
}
void Agent::activateLocalSocket() {
activeSocket = localSocket;
_activeSocket = _localSocket;
}
void Agent::activatePublicSocket() {
activeSocket = publicSocket;
}
AgentData* Agent::getLinkedData() {
return linkedData;
}
void Agent::setLinkedData(AgentData *newData) {
linkedData = newData;
_activeSocket = _publicSocket;
}
bool Agent::operator==(const Agent& otherAgent) {
return matches(otherAgent.publicSocket, otherAgent.localSocket, otherAgent.type);
return matches(otherAgent._publicSocket, otherAgent._localSocket, otherAgent._type);
}
bool Agent::matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType) {
// checks if two agent objects are the same agent (same type + local + public address)
return type == otherAgentType
&& socketMatch(publicSocket, otherPublicSocket)
&& socketMatch(localSocket, otherLocalSocket);
return _type == otherAgentType
&& socketMatch(_publicSocket, otherPublicSocket)
&& socketMatch(_localSocket, otherLocalSocket);
}
void Agent::recordBytesReceived(int bytesReceived) {
@ -250,15 +204,15 @@ float Agent::getAverageKilobitsPerSecond() {
void Agent::printLog(Agent const& agent) {
char publicAddressBuffer[16] = {'\0'};
unsigned short publicAddressPort = loadBufferWithSocketInfo(publicAddressBuffer, agent.publicSocket);
unsigned short publicAddressPort = loadBufferWithSocketInfo(publicAddressBuffer, agent._publicSocket);
//char localAddressBuffer[16] = {'\0'};
//unsigned short localAddressPort = loadBufferWithSocketInfo(localAddressBuffer, agent.localSocket);
::printLog("# %d %s (%c) @ %s:%d\n",
agent.agentId,
agent._agentID,
agent.getTypeName(),
agent.type,
agent._type,
publicAddressBuffer,
publicAddressPort);
}

33
libraries/shared/src/Agent.h
View file

@ -23,7 +23,7 @@
class Agent {
public:
Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentId);
Agent(sockaddr *agentPublicSocket, sockaddr *agentLocalSocket, char agentType, uint16_t thisAgentID);
Agent(const Agent &otherAgent);
~Agent();
Agent& operator=(Agent otherAgent);
@ -31,12 +31,12 @@ public:
bool matches(sockaddr *otherPublicSocket, sockaddr *otherLocalSocket, char otherAgentType);
char getType() const;
char getType() const { return _type; }
void setType(char type) { _type = type; }
const char* getTypeName() const;
void setType(char newType);
uint16_t getAgentId();
void setAgentId(uint16_t thisAgentId);
uint16_t getAgentID() const { return _agentID; }
void setAgentID(uint16_t agentID) { _agentID = agentID;}
double getWakeMicrostamp() const { return _wakeMicrostamp; }
void setWakeMicrostamp(double wakeMicrostamp) { _wakeMicrostamp = wakeMicrostamp; }
@ -44,17 +44,18 @@ public:
double getLastHeardMicrostamp() const { return _lastHeardMicrostamp; }
void setLastHeardMicrostamp(double lastHeardMicrostamp) { _lastHeardMicrostamp = lastHeardMicrostamp; }
sockaddr* getPublicSocket();
void setPublicSocket(sockaddr *newSocket);
sockaddr* getLocalSocket();
void setLocalSocket(sockaddr *newSocket);
sockaddr* getActiveSocket();
sockaddr* getPublicSocket() const { return _publicSocket; }
void setPublicSocket(sockaddr *publicSocket) { _publicSocket = publicSocket; }
sockaddr* getLocalSocket() const { return _localSocket; }
void setLocalSocket(sockaddr *localSocket) { _localSocket = localSocket; }
sockaddr* getActiveSocket() const { return _activeSocket; }
void activatePublicSocket();
void activateLocalSocket();
AgentData* getLinkedData();
void setLinkedData(AgentData *newData);
AgentData* getLinkedData() const { return _linkedData; }
void setLinkedData(AgentData *linkedData) { _linkedData = linkedData; }
bool isAlive() const { return _isAlive; };
void setAlive(bool isAlive) { _isAlive = isAlive; };
@ -67,13 +68,13 @@ public:
private:
void swap(Agent &first, Agent &second);
sockaddr *publicSocket, *localSocket, *activeSocket;
char type;
uint16_t agentId;
sockaddr* _publicSocket, *_localSocket, *_activeSocket;
char _type;
uint16_t _agentID;
double _wakeMicrostamp;
double _lastHeardMicrostamp;
SimpleMovingAverage* _bytesReceivedMovingAverage;
AgentData* linkedData;
AgentData* _linkedData;
bool _isAlive;
};

2
libraries/shared/src/AgentList.cpp
View file

@ -184,7 +184,7 @@ Agent* AgentList::agentWithAddress(sockaddr *senderAddress) {
Agent* AgentList::agentWithID(uint16_t agentID) {
for(AgentList::iterator agent = begin(); agent != end(); agent++) {
if (agent->getAgentId() == agentID) {
if (agent->getAgentID() == agentID) {
return &(*agent);
}
}