Container.h

Go to the documentation of this file.

//                            Package   : omniIFR
//  Container.h               Created   : 2004/02/22
//                            Author    : Alex Tingle
//
//    Copyright (C) 2004 Alex Tingle.
//
//    This file is part of the omniIFR application.
//
//    omniIFR is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    omniIFR 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
#ifndef OMNIIFR__CONTAINER_H
#define OMNIIFR__CONTAINER_H

#include "IRObject.h"

#include <list>
#include <map>
#include <string.h>

using namespace CORBA;

namespace Omniifr {

class Contained_impl;
class PersistNode;

class Container_impl:
  public virtual POA_CORBA::Container,
  public virtual IRObject_impl
{
public: // CORBA interface methods

  // methods that read

  Contained_ptr lookup(
    const char*    search_name 
  );

  virtual ContainedSeq* contents(
    DefinitionKind limit_type,
    Boolean        exclude_inherited
  );

  ContainedSeq* lookup_name(
    const char*    search_name, 
    Long           levels_to_search,
    DefinitionKind limit_type,
    Boolean        exclude_inherited
  );

  CORBA::Container::DescriptionSeq* describe_contents(
    DefinitionKind limit_type,
    Boolean        exclude_inherited,
    Long           max_returned_objs
  );

  // methods that write
  ModuleDef_ptr create_module(
    const char* id,      
    const char* name,    
    const char* version  
  );

  ConstantDef_ptr create_constant(
    const char* id,      
    const char* name,    
    const char* version, 
    IDLType_ptr type,
    const Any&  value
  );

  StructDef_ptr create_struct(
    const char* id,      
    const char* name,    
    const char* version, 
    const StructMemberSeq& members
  );

  UnionDef_ptr create_union(
    const char* id,      
    const char* name,    
    const char* version, 
    IDLType_ptr discriminator_type,
    const UnionMemberSeq& members
  );

  EnumDef_ptr create_enum(
    const char* id,      
    const char* name,    
    const char* version, 
    const EnumMemberSeq& members
  );

  AliasDef_ptr create_alias(
    const char* id,      
    const char* name,    
    const char* version, 
    IDLType_ptr original_type
  );

  InterfaceDef_ptr create_interface(
    const char* id,      
    const char* name,    
    const char* version, 
    const InterfaceDefSeq& base_interfaces
  );

  ExceptionDef_ptr create_exception(
    const char* id,      
    const char* name,    
    const char* version, 
    const StructMemberSeq& members
  );

  ValueDef_ptr create_value(
    const char* id,      
    const char* name,    
    const char* version, 
    Boolean                is_custom,
    Boolean                is_abstract,
    ValueDef_ptr           base_value,
    Boolean                is_truncatable,
    const ValueDefSeq&     abstract_base_values,
    const InterfaceDefSeq& supported_interfaces,
    const InitializerSeq&  initializers
  );

  ValueBoxDef_ptr create_value_box(
    const char* id,      
    const char* name,    
    const char* version, 
    IDLType_ptr original_type_def
  );

  NativeDef_ptr create_native(
    const char* id,      
    const char* name,    
    const char* version  
  );

  AbstractInterfaceDef_ptr create_abstract_interface(
    const char* id,      
    const char* name,    
    const char* version, 
    const AbstractInterfaceDefSeq& base_interfaces
  );

  /* Not implemented in omniORB.
  LocalInterfaceDef_ptr create_local_interface(
    const char* id,      ///< typedef: RepositoryId
    const char* name,    ///< typedef: Identifier
    const char* version, ///< typedef: VersionSpec
    const InterfaceDefSeq& base_interfaces
  );
  */

protected:
  void dependentObjectSet(set<const IRObject_impl*>& result) const;
  void containedObjectSet(set<const IRObject_impl*>& result) const;
  
  void recreate(PersistNode* node, map<IRObject_impl*,PersistNode*>& todo);
  
  void outputContents(ostream &os) const;

public:
  Container_impl();
  virtual ~Container_impl() {}
  virtual void uncheckedDestroy() =0;

  Contained_impl* lookupServant(
    const char* searchName, 
    bool        matchCase
  );

  virtual bool canContain(DefinitionKind kind)=0;

  void addContained(Contained_impl* contained);
  void removeContained(Contained_impl* contained);

private:
  list<Contained_impl*> _contents;

  struct EqualName{
    EqualName(const char* name,bool matchCase):_name(name),_case(matchCase){}
    bool operator()(Contained_ptr c){return test(c->name());}
    bool operator()(Contained_impl* c);
    bool test(char* name) {
      String_var cname(name); // consumes parameter
      if(_case)
        return(0==strcmp(cname.in(),_name.in()));
      else
        return(0==strcasecmp(cname.in(),_name.in()));
    }
    CORBA::String_var _name;
    bool              _case;
  };
}; // Container_impl

} // end namespace Omniifr

#endif // OMNIIFR__CONTAINER_H

---