729 lines
15 KiB
C++
729 lines
15 KiB
C++
/*
|
|
This file is part of SECONDO.
|
|
|
|
Copyright (C) 2011, University in Hagen, Department of Computer Science,
|
|
Database Systems for New Applications.
|
|
|
|
SECONDO is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
SECONDO is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with SECONDO; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
2012, August Simone Jandt
|
|
|
|
1 Includes
|
|
|
|
*/
|
|
|
|
#include "JPoint.h"
|
|
#include "ListUtils.h"
|
|
#include "NestedList.h"
|
|
#include "NList.h"
|
|
#include "Symbols.h"
|
|
#include "ManageJNet.h"
|
|
|
|
using namespace jnetwork;
|
|
using namespace std;
|
|
|
|
/*
|
|
1 Implementation of class ~JPoint~
|
|
|
|
1.1 Constructors and Deconstructors
|
|
|
|
*/
|
|
|
|
JPoint::JPoint(): Attribute()
|
|
{}
|
|
|
|
JPoint::JPoint(const bool def) :
|
|
Attribute(def), npos(def)
|
|
{
|
|
strcpy(nid,"");
|
|
}
|
|
|
|
JPoint::JPoint(const JPoint& other) :
|
|
Attribute(other.IsDefined()), npos(false)
|
|
{
|
|
if (other.IsDefined())
|
|
{
|
|
strcpy(nid, *other.GetNetworkId());
|
|
npos = other.GetLocation();
|
|
}
|
|
else
|
|
{
|
|
strcpy(nid, "");
|
|
}
|
|
}
|
|
|
|
JPoint::JPoint(const string netId, const RouteLocation& rloc,
|
|
const bool check /*=true*/) :
|
|
Attribute(rloc.IsDefined()), npos(rloc)
|
|
{
|
|
strcpy(nid, netId.c_str());
|
|
if (check) SetDefined(PosExists(0));
|
|
}
|
|
|
|
JPoint::JPoint(const JNetwork* jnet, const RouteLocation* rloc,
|
|
const bool check /*=true*/) :
|
|
Attribute(true), npos(*rloc)
|
|
{
|
|
if (jnet != 0 && rloc != 0 && jnet->IsDefined() && rloc->IsDefined())
|
|
{
|
|
strcpy(nid, *jnet->GetId());
|
|
if (check) SetDefined(PosExists(jnet));
|
|
}
|
|
else
|
|
{
|
|
SetDefined(false);
|
|
strcpy(nid, "");
|
|
}
|
|
}
|
|
|
|
JPoint::~JPoint()
|
|
{}
|
|
|
|
/*
|
|
1.1 Getter and Setter for private Attributes
|
|
|
|
*/
|
|
|
|
const STRING_T* JPoint::GetNetworkId() const
|
|
{
|
|
return &nid;
|
|
}
|
|
|
|
RouteLocation JPoint::GetLocation() const
|
|
{
|
|
return npos;
|
|
}
|
|
|
|
void JPoint::SetNetId(const STRING_T& netId)
|
|
{
|
|
strcpy(nid, netId);
|
|
}
|
|
|
|
void JPoint::SetPosition(const RouteLocation& rloc, const bool check /*=true*/,
|
|
const JNetwork* jnet /*=0*/)
|
|
{
|
|
npos = rloc;
|
|
if (check)
|
|
{
|
|
SetDefined(PosExists(jnet));
|
|
}
|
|
}
|
|
|
|
/*
|
|
1.1 Override Methods from Attribute
|
|
|
|
*/
|
|
|
|
void JPoint::CopyFrom(const Attribute* right)
|
|
{
|
|
*this = *((JPoint*) right);
|
|
}
|
|
|
|
Attribute::StorageType JPoint::GetStorageType() const
|
|
{
|
|
return Default;
|
|
}
|
|
|
|
size_t JPoint::HashValue() const
|
|
{
|
|
return strlen(nid) + npos.HashValue();
|
|
}
|
|
|
|
JPoint* JPoint::Clone() const
|
|
{
|
|
return new JPoint(*this);
|
|
}
|
|
|
|
bool JPoint::Adjacent(const Attribute* attrib) const
|
|
{
|
|
if (attrib->IsDefined())
|
|
{
|
|
JPoint in(*(JPoint*) attrib);
|
|
if (IsDefined() && strcmp(nid, *in.GetNetworkId()) == 0)
|
|
{
|
|
return npos.Adjacent(in.GetLocation());
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int JPoint::Compare(const void* l, const void* r)
|
|
{
|
|
if (l != 0 && r != 0)
|
|
{
|
|
JPoint lp(*(JPoint*) l);
|
|
JPoint rp(*(JPoint*) r);
|
|
return lp.Compare(rp);
|
|
}
|
|
else if ( l != 0 && r == 0)
|
|
return 1;
|
|
else if (l == 0 && r != 0)
|
|
return -1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int JPoint::Compare(const Attribute* rhs) const
|
|
{
|
|
if (rhs != 0)
|
|
{
|
|
JPoint in(*(JPoint*) rhs);
|
|
return Compare(in);
|
|
}
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
int JPoint::Compare(const JPoint& rhs) const
|
|
{
|
|
if (!IsDefined() && !rhs.IsDefined()) return 0;
|
|
if (IsDefined() && !rhs.IsDefined()) return 1;
|
|
if (!IsDefined() && rhs.IsDefined()) return -1;
|
|
int test = strcmp(nid, *rhs.GetNetworkId());
|
|
if (test != 0) return test;
|
|
return npos.Compare(rhs.GetLocation());
|
|
}
|
|
|
|
size_t JPoint::Sizeof() const
|
|
{
|
|
return sizeof(JPoint);
|
|
}
|
|
|
|
ostream& JPoint::Print(ostream& os) const
|
|
{
|
|
os << "JPoint ";
|
|
if (IsDefined())
|
|
{
|
|
os << "in Network: " << nid
|
|
<< " at: ";
|
|
npos.Print(os);
|
|
os << endl;
|
|
}
|
|
else
|
|
{
|
|
os << Symbol::UNDEFINED() << endl;
|
|
}
|
|
return os;
|
|
}
|
|
|
|
const string JPoint::BasicType()
|
|
{
|
|
return "jpoint";
|
|
}
|
|
|
|
const bool JPoint::checkType(const ListExpr type)
|
|
{
|
|
return listutils::isSymbol(type, BasicType());
|
|
}
|
|
|
|
/*
|
|
1.1 Standard Operators
|
|
|
|
*/
|
|
|
|
JPoint& JPoint::operator=(const JPoint& other)
|
|
{
|
|
SetDefined(other.IsDefined());
|
|
if (other.IsDefined())
|
|
{
|
|
strcpy(nid, *other.GetNetworkId());
|
|
npos = other.GetLocation();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool JPoint::operator==(const JPoint& other) const
|
|
{
|
|
return (Compare(other) == 0);
|
|
}
|
|
|
|
bool JPoint::operator!=(const JPoint& other) const
|
|
{
|
|
return (Compare(other) != 0);
|
|
}
|
|
|
|
bool JPoint::operator<(const JPoint& other) const
|
|
{
|
|
return (Compare(other) < 0);
|
|
}
|
|
|
|
bool JPoint::operator<=(const JPoint& other) const
|
|
{
|
|
return (Compare(other) < 1);
|
|
}
|
|
|
|
bool JPoint::operator>(const JPoint& other) const
|
|
{
|
|
return (Compare(other) > 0);
|
|
}
|
|
|
|
bool JPoint::operator>=(const JPoint& other) const
|
|
{
|
|
return (Compare(other) > -1);
|
|
}
|
|
|
|
/*
|
|
1.1 Operators for Secondo Integration
|
|
|
|
*/
|
|
|
|
ListExpr JPoint::Out(ListExpr typeInfo, Word value)
|
|
{
|
|
JPoint* in = (JPoint*) value.addr;
|
|
if (in == 0 || !in->IsDefined())
|
|
{
|
|
return nl->SymbolAtom(Symbol::UNDEFINED());
|
|
}
|
|
else
|
|
{
|
|
NList netList(*in->GetNetworkId(),true,false);
|
|
RouteLocation netPos(in->GetLocation());
|
|
return nl->TwoElemList(netList.listExpr(),
|
|
RouteLocation::Out(nl->TheEmptyList(),
|
|
SetWord((void*) &netPos)));
|
|
}
|
|
}
|
|
|
|
Word JPoint::In(const ListExpr typeInfo, const ListExpr instance,
|
|
const int errorPos, ListExpr& errorInfo, bool& correct)
|
|
{
|
|
NList inlist(instance);
|
|
|
|
if (listutils::isSymbolUndefined( instance ))
|
|
{
|
|
correct = true;
|
|
return (new JPoint (false) );
|
|
}
|
|
else
|
|
{
|
|
if (inlist.length() == 2)
|
|
{
|
|
ListExpr netList = nl->First(instance);
|
|
string netId = nl->StringValue(netList);
|
|
Word w = RouteLocation::In(nl->TheEmptyList(),
|
|
nl->Second(instance),
|
|
errorPos,
|
|
errorInfo,
|
|
correct);
|
|
if (!correct)
|
|
{
|
|
cmsg.inFunError("Second Element must be RouteLocation");
|
|
return SetWord(Address(0));
|
|
}
|
|
RouteLocation* rloc = (RouteLocation*) w.addr;
|
|
JPoint* res = new JPoint(netId, *rloc);
|
|
rloc->DeleteIfAllowed();
|
|
return SetWord(res);
|
|
}
|
|
}
|
|
correct = false;
|
|
cmsg.inFunError("list length should be 1 or 2");;
|
|
return SetWord(Address(0));
|
|
}
|
|
|
|
Word JPoint::Create(const ListExpr typeInfo)
|
|
{
|
|
return SetWord(new JPoint(true));
|
|
}
|
|
|
|
void JPoint::Delete( const ListExpr typeInfo, Word& w )
|
|
{
|
|
((JPoint*) w.addr)->DeleteIfAllowed();
|
|
w.addr = 0;
|
|
}
|
|
|
|
void JPoint::Close( const ListExpr typeInfo, Word& w )
|
|
{
|
|
((JPoint*) w.addr)->DeleteIfAllowed();
|
|
w.addr = 0;
|
|
}
|
|
|
|
Word JPoint::Clone( const ListExpr typeInfo, const Word& w )
|
|
{
|
|
return SetWord(new JPoint(*(JPoint*) w.addr));
|
|
}
|
|
|
|
void* JPoint::Cast( void* addr )
|
|
{
|
|
return (new (addr) JPoint);
|
|
}
|
|
|
|
bool JPoint::KindCheck ( ListExpr type, ListExpr& errorInfo )
|
|
{
|
|
return checkType(type);
|
|
}
|
|
|
|
int JPoint::SizeOf()
|
|
{
|
|
return sizeof(JPoint);
|
|
}
|
|
|
|
ListExpr JPoint::Property()
|
|
{
|
|
return nl->TwoElemList(
|
|
nl->FourElemList(
|
|
nl->StringAtom("Signature"),
|
|
nl->StringAtom("Example Type List"),
|
|
nl->StringAtom("List Rep"),
|
|
nl->StringAtom("Example List")),
|
|
nl->FourElemList(
|
|
nl->StringAtom("-> " + Kind::DATA()),
|
|
nl->StringAtom(BasicType()),
|
|
nl->TextAtom("(" + CcString::BasicType() + " " +
|
|
RouteLocation::BasicType() + "), describes a position in " +
|
|
"the given network."),
|
|
nl->StringAtom(Example())));
|
|
}
|
|
|
|
|
|
/*
|
|
1.1 Other Operations
|
|
|
|
*/
|
|
|
|
string JPoint::Example()
|
|
{
|
|
return "(netname " + RouteLocation::Example() + ")";
|
|
}
|
|
|
|
/*
|
|
1.1.1 FromSpatial
|
|
|
|
*/
|
|
|
|
void JPoint::FromSpatial(const JNetwork* jnet, const Point* in)
|
|
{
|
|
if (jnet != NULL && jnet->IsDefined() &&
|
|
in != NULL && in->IsDefined())
|
|
{
|
|
SetDefined(in->IsDefined());
|
|
strcpy(nid,*(jnet->GetId()));
|
|
RouteLocation* rloc = jnet->GetNetworkValueOf(in);
|
|
if (rloc != NULL)
|
|
{
|
|
npos = *rloc;
|
|
rloc->DeleteIfAllowed();
|
|
}
|
|
else
|
|
SetDefined(false);
|
|
}
|
|
else
|
|
SetDefined(false);
|
|
}
|
|
|
|
/*
|
|
1.1.1 ToSpatial
|
|
|
|
*/
|
|
|
|
void JPoint::ToSpatial(Point& result) const
|
|
{
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
Point* tmp = jnet->GetSpatialValueOf(*this);
|
|
result = *tmp;
|
|
tmp->DeleteIfAllowed();
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result.SetDefined(false);
|
|
}
|
|
|
|
/*
|
|
1.1.1 NetBox
|
|
|
|
*/
|
|
|
|
Rectangle< 2 > JPoint::NetBox() const
|
|
{
|
|
if (IsDefined())
|
|
return npos.NetBox();
|
|
else
|
|
return Rectangle<2>(false);
|
|
}
|
|
|
|
/*
|
|
1.1.1 OtherNetworkPositions
|
|
|
|
*/
|
|
|
|
JListRLoc* JPoint::OtherNetworkPositions() const
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
JListRLoc* result = jnet->GetNetworkValuesOf(npos);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
1.1.1 ShortestPathTree
|
|
|
|
*/
|
|
|
|
void JPoint::ShortestPathTree(DbArray<PairIntDouble>* result) const
|
|
{
|
|
//cout << "JPShortestPathTree for: " << *this << endl;
|
|
if (result != NULL)
|
|
{
|
|
result->clean();
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->ShortestPathTree(this->GetLocation(), result,
|
|
numeric_limits< double >::max());
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
}
|
|
}
|
|
|
|
void JPoint::ReverseShortestPathTree(DbArray< PairIntDouble >* result) const
|
|
{
|
|
if (result != NULL)
|
|
{
|
|
result->clean();
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->ReverseShortestPathTree(this->GetLocation(), result,
|
|
numeric_limits< double >::max());
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
1.1.1 ShortestPath
|
|
|
|
*/
|
|
|
|
void JPoint::ShortestPath(const JPoint* target,
|
|
JPath* result) const
|
|
{
|
|
result->Clear();
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
result->SetNetworkId(nid);
|
|
if (!(npos.IsOnSamePlace(target->GetLocation())))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->ShortestPath(npos, target->GetLocation(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result->SetDefined(true);
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::ShortestPath(const JPoints* target, JPath* result) const
|
|
{
|
|
result->Clear();
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
result->SetNetworkId(nid);
|
|
if (!target->Contains(this))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->ShortestPath(npos, target->GetRouteLocations(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result->SetDefined(true);
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::ShortestPath(const JLine* target, JPath* result) const
|
|
{
|
|
result->Clear();
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
result->SetNetworkId(nid);
|
|
if (!target->Contains(this))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
JPoints* bgp = new JPoints(false);
|
|
target->GetBGP(bgp);
|
|
jnet->ShortestPath(npos, bgp->GetRouteLocations(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
bgp->Destroy();
|
|
bgp->DeleteIfAllowed();
|
|
}
|
|
else
|
|
result->SetDefined(true);
|
|
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
/*
|
|
1.1.1 Netdistance
|
|
|
|
*/
|
|
|
|
void JPoint::Netdistance(const jnetwork::JPoint* target, CcReal* result) const
|
|
{
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
if (!(npos.IsOnSamePlace(target->GetLocation())))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->Netdistance(npos, target->GetLocation(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
{
|
|
result->SetDefined(true);
|
|
result->Set(0.0);
|
|
}
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::Netdistance(const jnetwork::JPoints* target, CcReal* result) const
|
|
{
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
if (!target->Contains(this))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->Netdistance(npos, target->GetRouteLocations(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
{
|
|
result->SetDefined(true);
|
|
result->Set(0.0);
|
|
}
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::Netdistance(const jnetwork::JLine* target, CcReal* result) const
|
|
{
|
|
if (IsDefined() && target != NULL && target->IsDefined() &&
|
|
strcmp(nid, *target->GetNetworkId()) == 0)
|
|
{
|
|
if (!target->Contains(this))
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
JPoints* bgp = new JPoints(false);
|
|
target->GetBGP(bgp);
|
|
jnet->Netdistance(npos, bgp->GetRouteLocations(), result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
bgp->Destroy();
|
|
bgp->DeleteIfAllowed();
|
|
}
|
|
else
|
|
{
|
|
result->SetDefined(true);
|
|
result->Set(0.0);
|
|
}
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
/*
|
|
1.1.1 Network Parts Around
|
|
|
|
*/
|
|
|
|
void JPoint::InCircle(const double netdist, JLine* result) const
|
|
{
|
|
if (result != 0) result->Clear();
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->InCircle(this->GetLocation(), netdist, result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::OutCircle(const double netdist, JLine* result) const
|
|
{
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->OutCircle(this->GetLocation(), netdist, result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
void JPoint::Circle(const double netdist, JLine* result) const
|
|
{
|
|
if (IsDefined())
|
|
{
|
|
JNetwork* jnet = ManageJNet::GetNetwork(nid);
|
|
jnet->Circle(this->GetLocation(), netdist, result);
|
|
ManageJNet::CloseNetwork(jnet);
|
|
}
|
|
else
|
|
result->SetDefined(false);
|
|
}
|
|
|
|
/*
|
|
1.1 Private Methods
|
|
|
|
1.1.1 PosExists
|
|
|
|
*/
|
|
|
|
bool JPoint::PosExists(const JNetwork* jnet /*=0*/) const
|
|
{
|
|
bool result = false;
|
|
if (jnet != 0)
|
|
result = jnet->Contains(npos);
|
|
else
|
|
{
|
|
JNetwork* net = ManageJNet::GetNetwork(nid);
|
|
if (net != 0)
|
|
{
|
|
result = net->Contains(npos);
|
|
ManageJNet::CloseNetwork(net);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
1 Overwrite output operator
|
|
|
|
*/
|
|
|
|
ostream& operator<<(ostream& os, const JPoint& jp)
|
|
{
|
|
jp.Print(os);
|
|
return os;
|
|
}
|