Esempio n. 1
0
  public static void main(String args[]) {
    // public void run() {
    String nomOffice = args[0];
    // Tableau des id/nom des sites
    OfficeDBManager db = new OfficeDBManager();

    Hashtable<Short, String> codeSite = new Hashtable<Short, String>();
    // Table des id des sites
    short[] idSite = db.getIdSites();
    for (int i = 0; i < idSite.length; i++) {
      codeSite.put(idSite[i], db.getCodeSite(idSite[i]));
    }

    try {
      org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init(args, null);

      // Gestion du POA
      // ****************
      // Recuperation du POA
      POA rootPOA = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));

      // Creation du servant
      // *********************
      OfficeImpl monOffice = new OfficeImpl(orb, codeSite);

      // Activer le servant au sein du POA et recuperer son ID
      byte[] monOfficeId = rootPOA.activate_object(monOffice);

      // Activer le POA manager
      rootPOA.the_POAManager().activate();

      /** ****** Enregistrement dans le service de nommage ******* */

      // Recuperation du naming service
      NamingContext nameRoot =
          org.omg.CosNaming.NamingContextHelper.narrow(
              orb.resolve_initial_references("NameService"));

      // Construction du nom a enregistrer
      org.omg.CosNaming.NameComponent[] nameToRegister = new org.omg.CosNaming.NameComponent[1];
      nameToRegister[0] = new org.omg.CosNaming.NameComponent(nomOffice, "");

      // Enregistrement de l'objet CORBA dans le service de noms
      nameRoot.rebind(nameToRegister, rootPOA.servant_to_reference(monOffice));
      System.out.println("==> Nom '" + nomOffice + "' est enregistre dans le service de noms.");

      String IORServant = orb.object_to_string(rootPOA.servant_to_reference(monOffice));
      System.out.println("L'objet possede la reference suivante :");
      System.out.println(IORServant);

      // Lancement de l'ORB et mise en attente de requete
      // **************************************************
      orb.run();

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 public org.omg.CORBA.TypeCode _type() {
   return org.omg.CosNaming.NamingContextHelper.type();
 }
 public void _write(org.omg.CORBA.portable.OutputStream o) {
   org.omg.CosNaming.NamingContextHelper.write(o, value);
 }
 public void _read(org.omg.CORBA.portable.InputStream i) {
   value = org.omg.CosNaming.NamingContextHelper.read(i);
 }
  public org.omg.CORBA.portable.OutputStream _invoke(
      String $method,
      org.omg.CORBA.portable.InputStream in,
      org.omg.CORBA.portable.ResponseHandler $rh) {
    org.omg.CORBA.portable.OutputStream out = null;
    java.lang.Integer __method = (java.lang.Integer) _methods.get($method);
    if (__method == null)
      throw new org.omg.CORBA.BAD_OPERATION(0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);

    switch (__method.intValue()) {

        /**
         * Creates a binding of a name and an object in the naming context. Naming contexts that are
         * bound using bind do not participate in name resolution when compound names are passed to
         * be resolved.
         *
         * @param n Name of the object
         *     <p>
         * @param obj The Object to bind with the given name
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.AlreadyBound Indicates an object is
         *     already bound to the specified name.
         *     <p>
         */
      case 0: // CosNaming/NamingContext/bind
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CORBA.Object obj = org.omg.CORBA.ObjectHelper.read(in);
            this.bind(n, obj);
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.write(out, $ex);
          }
          break;
        }

        /**
         * Names an object that is a naming context. Naming contexts that are bound using
         * bind_context() participate in name resolution when compound names are passed to be
         * resolved.
         *
         * @param n Name of the object
         *     <p>
         * @param nc NamingContect object to bind with the given name
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.AlreadyBound Indicates an object is
         *     already bound to the specified name.
         *     <p>
         */
      case 1: // CosNaming/NamingContext/bind_context
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CosNaming.NamingContext nc = org.omg.CosNaming.NamingContextHelper.read(in);
            this.bind_context(n, nc);
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.write(out, $ex);
          }
          break;
        }

        /**
         * Creates a binding of a name and an object in the naming context even if the name is
         * already bound in the context. Naming contexts that are bound using rebind do not
         * participate in name resolution when compound names are passed to be resolved.
         *
         * @param n Name of the object
         *     <p>
         * @param obj The Object to rebind with the given name
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         */
      case 2: // CosNaming/NamingContext/rebind
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CORBA.Object obj = org.omg.CORBA.ObjectHelper.read(in);
            this.rebind(n, obj);
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          }
          break;
        }

        /**
         * Creates a binding of a name and a naming context in the naming context even if the name
         * is already bound in the context. Naming contexts that are bound using rebind_context()
         * participate in name resolution when compound names are passed to be resolved.
         *
         * @param n Name of the object
         *     <p>
         * @param nc NamingContect object to rebind with the given name
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         */
      case 3: // CosNaming/NamingContext/rebind_context
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CosNaming.NamingContext nc = org.omg.CosNaming.NamingContextHelper.read(in);
            this.rebind_context(n, nc);
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          }
          break;
        }

        /**
         * The resolve operation is the process of retrieving an object bound to a name in a given
         * context. The given name must exactly match the bound name. The naming service does not
         * return the type of the object. Clients are responsible for "narrowing" the object to the
         * appropriate type. That is, clients typically cast the returned object from Object to a
         * more specialized interface.
         *
         * @param n Name of the object
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         */
      case 4: // CosNaming/NamingContext/resolve
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CORBA.Object $result = null;
            $result = this.resolve(n);
            out = $rh.createReply();
            org.omg.CORBA.ObjectHelper.write(out, $result);
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          }
          break;
        }

        /**
         * The unbind operation removes a name binding from a context.
         *
         * @param n Name of the object
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         */
      case 5: // CosNaming/NamingContext/unbind
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            this.unbind(n);
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          }
          break;
        }

        /**
         * The list operation allows a client to iterate through a set of bindings in a naming
         * context.
         *
         * <p>The list operation returns at most the requested number of bindings in BindingList bl.
         *
         * <ul>
         *   <li>If the naming context contains additional bindings, the list operation returns a
         *       BindingIterator with the additional bindings.
         *   <li>If the naming context does not contain additional bindings, the binding iterator is
         *       a nil object reference.
         * </ul>
         *
         * @param how_many the maximum number of bindings to return
         *     <p>
         * @param bl the returned list of bindings
         *     <p>
         * @param bi the returned binding iterator
         *     <p>
         */
      case 6: // CosNaming/NamingContext/list
        {
          int how_many = in.read_ulong();
          org.omg.CosNaming.BindingListHolder bl = new org.omg.CosNaming.BindingListHolder();
          org.omg.CosNaming.BindingIteratorHolder bi =
              new org.omg.CosNaming.BindingIteratorHolder();
          this.list(how_many, bl, bi);
          out = $rh.createReply();
          org.omg.CosNaming.BindingListHelper.write(out, bl.value);
          org.omg.CosNaming.BindingIteratorHelper.write(out, bi.value);
          break;
        }

        /**
         * This operation returns a naming context implemented by the same naming server as the
         * context on which the operation was invoked. The new context is not bound to any name.
         */
      case 7: // CosNaming/NamingContext/new_context
        {
          org.omg.CosNaming.NamingContext $result = null;
          $result = this.new_context();
          out = $rh.createReply();
          org.omg.CosNaming.NamingContextHelper.write(out, $result);
          break;
        }

        /**
         * This operation creates a new context and binds it to the name supplied as an argument.
         * The newly-created context is implemented by the same naming server as the context in
         * which it was bound (that is, the naming server that implements the context denoted by the
         * name argument excluding the last component).
         *
         * @param n Name of the object
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.NotFound Indicates the name does not
         *     identify a binding.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.AlreadyBound Indicates an object is
         *     already bound to the specified name.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.CannotProceed Indicates that the
         *     implementation has given up for some reason. The client, however, may be able to
         *     continue the operation at the returned naming context.
         *     <p>
         * @exception org.omg.CosNaming.NamingContextPackage.InvalidName Indicates that the name is
         *     invalid.
         *     <p>
         */
      case 8: // CosNaming/NamingContext/bind_new_context
        {
          try {
            org.omg.CosNaming.NameComponent n[] = org.omg.CosNaming.NameHelper.read(in);
            org.omg.CosNaming.NamingContext $result = null;
            $result = this.bind_new_context(n);
            out = $rh.createReply();
            org.omg.CosNaming.NamingContextHelper.write(out, $result);
          } catch (org.omg.CosNaming.NamingContextPackage.NotFound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotFoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.AlreadyBound $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.AlreadyBoundHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.CannotProceed $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.CannotProceedHelper.write(out, $ex);
          } catch (org.omg.CosNaming.NamingContextPackage.InvalidName $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.InvalidNameHelper.write(out, $ex);
          }
          break;
        }

        /**
         * The destroy operation deletes a naming context. If the naming context contains bindings,
         * the NotEmpty exception is raised.
         *
         * @exception org.omg.CosNaming.NamingContextPackage.NotEmpty Indicates that the Naming
         *     Context contains bindings.
         */
      case 9: // CosNaming/NamingContext/destroy
        {
          try {
            this.destroy();
            out = $rh.createReply();
          } catch (org.omg.CosNaming.NamingContextPackage.NotEmpty $ex) {
            out = $rh.createExceptionReply();
            org.omg.CosNaming.NamingContextPackage.NotEmptyHelper.write(out, $ex);
          }
          break;
        }

      default:
        throw new org.omg.CORBA.BAD_OPERATION(0, org.omg.CORBA.CompletionStatus.COMPLETED_MAYBE);
    }

    return out;
  } // _invoke