/// <summary>
/// Obtém todos os receptáculos do componente.
/// </summary>
/// <returns>O conjunto de descritores de receptáculos.</returns>
public ReceptacleDescription[] getReceptacles()
{
IDictionary <String, Receptacle> receptacles =
context.GetReceptacles();
return(CreateReceptacleDescriptionVector(receptacles));
}
/// <summary>
/// Conecta uma faceta a um receptáculo.
/// </summary>
/// <param name="receptacle">
/// O nome do receptáculo que se deseja conectar.
/// </param>
/// <param name="obj">
/// A referência para a faceta que se deseja conectar.
/// </param>
/// <exception cref="InvalidName">
/// Caso o nome do receptáculo seja inválido.
/// </exception>
/// <exception cref="InvalidConnection">
/// Caso a conexão não possa ser estabelecida, este erro pode acontecer
/// caso o <c>obj</c> não implemente a interface do receptáculo.
/// </exception>
/// <exception cref="AlreadyConnected">
/// Caso a faceta já esteja conectada.
/// </exception>
/// <exception cref="ExceededConnectionLimit">
/// Caso o número de conexões tenha excedido o limite configurado.
/// </exception>
public int connect(string receptacle, MarshalByRefObject obj)
{
IDictionary <string, Receptacle> receptacles =
context.GetReceptacles();
if (!receptacles.ContainsKey(receptacle))
{
throw new InvalidName {
name = receptacle
}
}
;
Receptacle rec = receptacles[receptacle];
if ((!rec.IsMultiple) &&
(rec.GetConnectionsSize() > 0))
{
throw new AlreadyConnected();
}
if (!IiopNetUtil.CheckInterface(obj, rec.InterfaceName))
{
throw new InvalidConnection();
}
int id = rec.AddConnections(obj);
logger.InfoFormat("Conexão {0} adicionada ao receptáculo '{1}'", id,
receptacle);
return(id);
}
/// <summary>
/// Faz um dump do component
/// </summary>
/// <param name="component"></param>
private void DumpComponent(ComponentContext component)
{
ComponentId componentId = component.GetComponentId();
StringBuilder builder = new StringBuilder();
builder.AppendFormat("Componente {0}:{1}.{2}.{3} criado com sucesso.\n", componentId.name,
componentId.major_version, componentId.minor_version, componentId.patch_version);
IDictionary <String, Facet> facets = component.GetFacets();
IDictionary <String, Receptacle> receptacles = component.GetReceptacles();
if (facets.Count > 0)
{
builder.AppendLine("Facetas:");
}
foreach (Facet facet in facets.Values)
{
builder.AppendFormat(" {0} : {1}\n", facet.Name, facet.InterfaceName);
}
if (receptacles.Count > 0)
{
builder.AppendLine("Receptáculos:");
}
foreach (Receptacle receptacle in receptacles.Values)
{
builder.AppendFormat(" {0} : {1}\n", receptacle.Name, receptacle.InterfaceName);
}
logger.Info(builder.Remove(builder.Length - 1, 1));
}
public void connectDisconnectTest()
{
IReceptaclesServant target = new IReceptaclesServant(context);
int numConections = 5;
int actual;
HashSet <int> ids = new HashSet <int>();
for (int i = 0; i < numConections; i++)
{
string receptacle = receptacleNames[i % receptacleNames.Count];
actual = target.connect(receptacle, servant);
Assert.IsTrue(actual > 0);
bool added = ids.Add(actual);
Assert.IsTrue(added);
}
actual = 0;
foreach (var receptacle in context.GetReceptacles().Values)
{
actual += receptacle.GetConnections().Count;
}
Assert.AreEqual(numConections, actual);
foreach (var id in ids)
{
target.disconnect(id);
}
}
public void pong()
{
Console.WriteLine("[Executando o método pong no componente Pong]");
Receptacle receptacle = context.GetReceptacles()["PongRec"];
foreach (ConnectionDescription connection in receptacle.GetConnections())
{
PingPongServer pingPongServer = connection.objref as PingPongServer;
pingPongServer.pong();
}
}
public void getReceptaclesTest()
{
IMetaInterfaceServant target = new IMetaInterfaceServant(context);
foreach (var name in receptacleNames)
{
context.AddReceptacle(name, interfaceName, false);
}
IDictionary <String, Receptacle> expected = context.GetReceptacles();
ReceptacleDescription[] actual = target.getReceptacles();
Assert.AreEqual(expected.Count, actual.Length);
for (int i = 0; i < actual.Length; i++)
{
Assert.IsTrue(expected.ContainsKey(actual[i].name));
}
}
/// <see cref="Equals" />
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
ComponentContext objContext = (ComponentContext)obj;
IDictionary <string, Facet> objFacets = objContext.GetFacets();
if (this.facets.Count != objFacets.Count)
{
return(false);
}
foreach (Facet facet in this.facets.Values)
{
if (!objFacets.ContainsKey(facet.Name))
{
return(false);
}
Facet objFacet = objFacets[facet.Name];
if (!facet.Equals(objFacet))
{
return(false);
}
}
IDictionary <string, Receptacle> objReceptacles = objContext.GetReceptacles();
if (this.receptacles.Count != objReceptacles.Count)
{
return(false);
}
foreach (Receptacle receptacle in this.receptacles.Values)
{
if (!objReceptacles.ContainsKey(receptacle.Name))
{
return(false);
}
Receptacle objReceptacle = objReceptacles[receptacle.Name];
if (!receptacle.Equals(objReceptacle))
{
return(false);
}
}
if (this.componentId.name != objContext.GetComponentId().name)
{
return(false);
}
if (this.componentId.major_version != objContext.GetComponentId().major_version)
{
return(false);
}
if (this.componentId.minor_version != objContext.GetComponentId().minor_version)
{
return(false);
}
if (this.componentId.patch_version != objContext.GetComponentId().patch_version)
{
return(false);
}
if (this.componentId.platform_spec != objContext.GetComponentId().platform_spec)
{
return(false);
}
return(true);
}
