comparison operators; started with Connection

1 files changed, 234 insertions, 234 deletions

diff --git a/cpp/src/Slice/Parser.cpp b/cpp/src/Slice/Parser.cpp
index b9489111101..ef93d6d5f2b 100644
--- a/cpp/src/Slice/Parser.cpp
+++ b/cpp/src/Slice/Parser.cpp
@@ -181,7 +181,7 @@ Slice::Container::createModule(const string& name)
 }
 
 ClassDefPtr
-Slice::Container::createClassDef(const string& name, bool local, bool intf, const ClassList& bases)
+Slice::Container::createClassDef(const string& name, bool intf, const ClassList& bases, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     for (ContainedList::const_iterator p = matches.begin(); p != matches.end(); ++p)
@@ -237,7 +237,7 @@ Slice::Container::createClassDef(const string& name, bool local, bool intf, cons
 	return 0;
     }
     
-    ClassDefPtr def = new ClassDef(this, name, local, intf, bases);
+    ClassDefPtr def = new ClassDef(this, name, intf, bases, local);
     _contents.push_back(def);
     
     for (ContainedList::const_iterator q = matches.begin(); q != matches.end(); ++q)
@@ -251,14 +251,14 @@ Slice::Container::createClassDef(const string& name, bool local, bool intf, cons
     // definition. This way the code generator can rely on always
     // having a class declaration available for lookup.
     //
-    ClassDeclPtr decl = createClassDecl(name, local, intf);
+    ClassDeclPtr decl = createClassDecl(name, intf, local);
     def->_declaration = decl;
 
     return def;
 }
 
 ClassDeclPtr
-Slice::Container::createClassDecl(const string& name, bool local, bool intf)
+Slice::Container::createClassDecl(const string& name, bool intf, bool local)
 {
     ClassDefPtr def;
 
@@ -323,7 +323,7 @@ Slice::Container::createClassDecl(const string& name, bool local, bool intf)
 	}
     }
 
-    ClassDeclPtr decl = new ClassDecl(this, name, local, intf);
+    ClassDeclPtr decl = new ClassDecl(this, name, intf, local);
     _contents.push_back(decl);
 
     if (def)
@@ -335,7 +335,7 @@ Slice::Container::createClassDecl(const string& name, bool local, bool intf)
 }
 
 ExceptionPtr
-Slice::Container::createException(const string& name, bool local, const ExceptionPtr& base)
+Slice::Container::createException(const string& name, const ExceptionPtr& base, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
@@ -363,13 +363,13 @@ Slice::Container::createException(const string& name, bool local, const Exceptio
 	return 0;
     }
 
-    ExceptionPtr p = new Exception(this, name, local, base);
+    ExceptionPtr p = new Exception(this, name, base, local);
     _contents.push_back(p);
     return p;
 }
 
 StructPtr
-Slice::Container::createStruct(const string& name)
+Slice::Container::createStruct(const string& name, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
@@ -397,13 +397,13 @@ Slice::Container::createStruct(const string& name)
 	return 0;
     }
 
-    StructPtr p = new Struct(this, name);
+    StructPtr p = new Struct(this, name, local);
     _contents.push_back(p);
     return p;
 }
 
 SequencePtr
-Slice::Container::createSequence(const string& name, const TypePtr& type)
+Slice::Container::createSequence(const string& name, const TypePtr& type, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
@@ -430,13 +430,13 @@ Slice::Container::createSequence(const string& name, const TypePtr& type)
 	return 0;
     }
 
-    SequencePtr p = new Sequence(this, name, type);
+    SequencePtr p = new Sequence(this, name, type, local);
     _contents.push_back(p);
     return p;
 }
 
 DictionaryPtr
-Slice::Container::createDictionary(const string& name, const TypePtr& keyType, const TypePtr& valueType)
+Slice::Container::createDictionary(const string& name, const TypePtr& keyType, const TypePtr& valueType, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
@@ -463,13 +463,13 @@ Slice::Container::createDictionary(const string& name, const TypePtr& keyType, c
 	return 0;
     }
 
-    DictionaryPtr p = new Dictionary(this, name, keyType, valueType);
+    DictionaryPtr p = new Dictionary(this, name, keyType, valueType, local);
     _contents.push_back(p);
     return p;
 }
 
 EnumPtr
-Slice::Container::createEnum(const string& name)
+Slice::Container::createEnum(const string& name, bool local)
 {
     ContainedList matches = _unit->findContents(thisScope() + name);
     if (!matches.empty())
@@ -496,7 +496,7 @@ Slice::Container::createEnum(const string& name)
 	return 0;
     }
 
-    EnumPtr p = new Enum(this, name);
+    EnumPtr p = new Enum(this, name, local);
     _contents.push_back(p);
     return p;
 }
@@ -1071,18 +1071,18 @@ Slice::Container::checkInterfaceAndLocal(const string& name, bool defined,
 // Module
 // ----------------------------------------------------------------------
 
-bool
-Slice::Module::uses(const ConstructedPtr&)
-{
-    return false;
-}
-
 Contained::ContainedType
 Slice::Module::containedType()
 {
     return ContainedTypeModule;
 }
 
+bool
+Slice::Module::uses(const ConstructedPtr&)
+{
+    return false;
+}
+
 void
 Slice::Module::visit(ParserVisitor* visitor)
 {
@@ -1109,10 +1109,17 @@ Slice::Module::Module(const ContainerPtr& container, const string& name) :
 // Constructed
 // ----------------------------------------------------------------------
 
-Slice::Constructed::Constructed(const ContainerPtr& container, const string& name) :
+bool
+Slice::Constructed::isLocal()
+{
+    return _local;
+}
+
+Slice::Constructed::Constructed(const ContainerPtr& container, const string& name, bool local) :
     Type(container->unit()),
     Contained(container, name),
-    SyntaxTreeBase(container->unit())
+    SyntaxTreeBase(container->unit()),
+    _local(local)
 {
 }
 
@@ -1134,15 +1141,15 @@ Slice::ClassDecl::definition()
 }
 
 bool
-Slice::ClassDecl::isLocal()
+Slice::ClassDecl::isInterface()
 {
-    return _local;
+    return _interface;
 }
 
-bool
-Slice::ClassDecl::isInterface()
+Contained::ContainedType
+Slice::ClassDecl::containedType()
 {
-    return _interface;
+    return ContainedTypeClass;
 }
 
 bool
@@ -1151,24 +1158,17 @@ Slice::ClassDecl::uses(const ConstructedPtr& constructed)
     return false;
 }
 
-Contained::ContainedType
-Slice::ClassDecl::containedType()
-{
-    return ContainedTypeClass;
-}
-
 void
 Slice::ClassDecl::visit(ParserVisitor* visitor)
 {
     visitor->visitClassDecl(this);
 }
 
-Slice::ClassDecl::ClassDecl(const ContainerPtr& container, const string& name, bool local, bool intf) :
-    Constructed(container, name),
+Slice::ClassDecl::ClassDecl(const ContainerPtr& container, const string& name, bool intf, bool local) :
+    Constructed(container, name, local),
     Type(container->unit()),
     Contained(container, name),
     SyntaxTreeBase(container->unit()),
-    _local(local),
     _interface(intf)
 {
 }
@@ -1416,27 +1416,21 @@ Slice::ClassDef::isAbstract()
 }
 
 bool
-Slice::ClassDef::isLocal()
-{
-    return _local;
-}
-
-bool
 Slice::ClassDef::isInterface()
 {
     return _interface;
 }
 
 bool
-Slice::ClassDef::hasDataMembers()
+Slice::ClassDef::isLocal()
 {
-    return _hasDataMembers;
+    return _local;
 }
 
 bool
-Slice::ClassDef::uses(const ConstructedPtr&)
+Slice::ClassDef::hasDataMembers()
 {
-    return false;
+    return _hasDataMembers;
 }
 
 Contained::ContainedType
@@ -1445,6 +1439,12 @@ Slice::ClassDef::containedType()
     return ContainedTypeClass;
 }
 
+bool
+Slice::ClassDef::uses(const ConstructedPtr&)
+{
+    return false;
+}
+
 void
 Slice::ClassDef::visit(ParserVisitor* visitor)
 {
@@ -1460,15 +1460,15 @@ Slice::ClassDef::visit(ParserVisitor* visitor)
     }
 }
 
-Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, bool local, bool intf,
-			  const ClassList& bases) :
+Slice::ClassDef::ClassDef(const ContainerPtr& container, const string& name, bool intf, const ClassList& bases,
+			  bool local) :
     Contained(container, name),
     Container(container->unit()),
     SyntaxTreeBase(container->unit()),
-    _local(local),
     _interface(intf),
     _hasDataMembers(false),
-    _bases(bases)
+    _bases(bases),
+    _local(local)
 {
     //
     // First element of bases may be a class, all others must be
@@ -1591,18 +1591,18 @@ Slice::Exception::isLocal()
     return _local;
 }
 
-bool
-Slice::Exception::uses(const ConstructedPtr&)
-{
-    return false;
-}
-
 Contained::ContainedType
 Slice::Exception::containedType()
 {
     return ContainedTypeException;
 }
 
+bool
+Slice::Exception::uses(const ConstructedPtr&)
+{
+    return false;
+}
+
 void
 Slice::Exception::visit(ParserVisitor* visitor)
 {
@@ -1618,12 +1618,12 @@ Slice::Exception::visit(ParserVisitor* visitor)
     }
 }
 
-Slice::Exception::Exception(const ContainerPtr& container, const string& name, bool local, const ExceptionPtr& base) :
+Slice::Exception::Exception(const ContainerPtr& container, const string& name, const ExceptionPtr& base, bool local) :
     Container(container->unit()),
     Contained(container, name),
     SyntaxTreeBase(container->unit()),
-    _local(local),
-    _base(base)
+    _base(base),
+    _local(local)
 {
 }
 
@@ -1697,18 +1697,18 @@ Slice::Struct::dataMembers()
     return result;
 }
 
-bool
-Slice::Struct::uses(const ConstructedPtr&)
-{
-    return false;
-}
-
 Contained::ContainedType
 Slice::Struct::containedType()
 {
     return ContainedTypeStruct;
 }
 
+bool
+Slice::Struct::uses(const ConstructedPtr&)
+{
+    return false;
+}
+
 void
 Slice::Struct::visit(ParserVisitor* visitor)
 {
@@ -1724,9 +1724,9 @@ Slice::Struct::visit(ParserVisitor* visitor)
     }
 }
 
-Slice::Struct::Struct(const ContainerPtr& container, const string& name) :
+Slice::Struct::Struct(const ContainerPtr& container, const string& name, bool local) :
     Container(container->unit()),
-    Constructed(container, name),
+    Constructed(container, name, local),
     Type(container->unit()),
     Contained(container, name),
     SyntaxTreeBase(container->unit())
@@ -1734,75 +1734,83 @@ Slice::Struct::Struct(const ContainerPtr& container, const string& name) :
 }
 
 // ----------------------------------------------------------------------
-// Operation
+// Sequence
 // ----------------------------------------------------------------------
 
 TypePtr
-Slice::Operation::returnType()
+Slice::Sequence::type()
 {
-    return _returnType;
+    return _type;
 }
 
-TypeStringList
-Slice::Operation::inputParameters()
+Contained::ContainedType
+Slice::Sequence::containedType()
 {
-    return _inParams;
+    return ContainedTypeSequence;
 }
 
-TypeStringList
-Slice::Operation::outputParameters()
+bool
+Slice::Sequence::uses(const ConstructedPtr& constructed)
 {
-    return _outParams;
+    ContainedPtr contained = ContainedPtr::dynamicCast(_type);
+    if (contained && contained == constructed)
+    {
+	return true;
+    }
+
+    return false;
 }
 
-ExceptionList
-Slice::Operation::throws()
+void
+Slice::Sequence::visit(ParserVisitor* visitor)
 {
-    return _throws;
+    visitor->visitSequence(this);
 }
 
-bool
-Slice::Operation::nonmutating()
+Slice::Sequence::Sequence(const ContainerPtr& container, const string& name, const TypePtr& type, bool local) :
+    Constructed(container, name, local),
+    Type(container->unit()),
+    Contained(container, name),
+    SyntaxTreeBase(container->unit()),
+    _type(type)
 {
-    return _nonmutating;
 }
 
-bool
-Slice::Operation::uses(const ConstructedPtr& constructed)
+// ----------------------------------------------------------------------
+// Dictionary
+// ----------------------------------------------------------------------
+
+TypePtr
+Slice::Dictionary::keyType()
 {
-    {
-	ContainedPtr contained = ContainedPtr::dynamicCast(_returnType);
-	if (contained && contained == constructed)
-	{
-	    return true;
-	}
-    }
+    return _keyType;
+}
 
-    TypeStringList::const_iterator p;
+TypePtr
+Slice::Dictionary::valueType()
+{
+    return _valueType;
+}
 
-    for (p = _inParams.begin(); p != _inParams.end(); ++p)
-    {
-	ContainedPtr contained = ContainedPtr::dynamicCast(p->first);
-	if (contained && contained == constructed)
-	{
-	    return true;
-	}
-    }
+Contained::ContainedType
+Slice::Dictionary::containedType()
+{
+    return ContainedTypeDictionary;
+}
 
-    for (p = _outParams.begin(); p != _outParams.end(); ++p)
+bool
+Slice::Dictionary::uses(const ConstructedPtr& constructed)
+{
     {
-	ContainedPtr contained = ContainedPtr::dynamicCast(p->first);
+	ContainedPtr contained = ContainedPtr::dynamicCast(_keyType);
 	if (contained && contained == constructed)
 	{
 	    return true;
 	}
     }
 
-    ExceptionList::const_iterator q;
-
-    for (q = _throws.begin(); q != _throws.end(); ++q)
     {
-	ContainedPtr contained = ContainedPtr::dynamicCast(*q);
+	ContainedPtr contained = ContainedPtr::dynamicCast(_valueType);
 	if (contained && contained == constructed)
 	{
 	    return true;
@@ -1812,237 +1820,229 @@ Slice::Operation::uses(const ConstructedPtr& constructed)
     return false;
 }
 
-Contained::ContainedType
-Slice::Operation::containedType()
-{
-    return ContainedTypeOperation;
-}
-
 void
-Slice::Operation::visit(ParserVisitor* visitor)
+Slice::Dictionary::visit(ParserVisitor* visitor)
 {
-    visitor->visitOperation(this);
+    visitor->visitDictionary(this);
 }
 
-Slice::Operation::Operation(const ContainerPtr& container, const string& name, const TypePtr& returnType,
-			    const TypeStringList& inParams, const TypeStringList& outParams,
-			    const ExceptionList& throws, bool nonmutating) :
+Slice::Dictionary::Dictionary(const ContainerPtr& container, const string& name, const TypePtr& keyType,
+			      const TypePtr& valueType, bool local) :
+    Constructed(container, name, local),
+    Type(container->unit()),
     Contained(container, name),
     SyntaxTreeBase(container->unit()),
-    _returnType(returnType),
-    _inParams(inParams),
-    _outParams(outParams),
-    _throws(throws),
-    _nonmutating(nonmutating)
+    _keyType(keyType),
+    _valueType(valueType)
 {
 }
 
 // ----------------------------------------------------------------------
-// DataMember
+// Enum
 // ----------------------------------------------------------------------
 
-TypePtr
-Slice::DataMember::type()
+EnumeratorList
+Slice::Enum::getEnumerators()
 {
-    return _type;
+    return _enumerators;
 }
 
-bool
-Slice::DataMember::uses(const ConstructedPtr& constructed)
+void
+Slice::Enum::setEnumerators(const EnumeratorList& ens)
 {
-    ContainedPtr contained = ContainedPtr::dynamicCast(_type);
-    if (contained && contained == constructed)
-    {
-	return true;
-    }
-
-    return false;
+    _enumerators = ens;
 }
 
 Contained::ContainedType
-Slice::DataMember::containedType()
+Slice::Enum::containedType()
 {
-    return ContainedTypeDataMember;
+    return ContainedTypeEnum;
+}
+
+bool
+Slice::Enum::uses(const ConstructedPtr& constructed)
+{
+    return false;
 }
 
 void
-Slice::DataMember::visit(ParserVisitor* visitor)
+Slice::Enum::visit(ParserVisitor* visitor)
 {
-    visitor->visitDataMember(this);
+    visitor->visitEnum(this);
 }
 
-Slice::DataMember::DataMember(const ContainerPtr& container, const string& name, const TypePtr& type) :
+Slice::Enum::Enum(const ContainerPtr& container, const string& name, bool local) :
+    Constructed(container, name, local),
+    Type(container->unit()),
     Contained(container, name),
-    SyntaxTreeBase(container->unit()),
-    _type(type)
+    SyntaxTreeBase(container->unit())
 {
 }
 
 // ----------------------------------------------------------------------
-// Sequence
+// Enumerator
 // ----------------------------------------------------------------------
 
-TypePtr
-Slice::Sequence::type()
+Contained::ContainedType
+Slice::Enumerator::containedType()
 {
-    return _type;
+    return ContainedTypeEnumerator;
 }
 
 bool
-Slice::Sequence::uses(const ConstructedPtr& constructed)
+Slice::Enumerator::uses(const ConstructedPtr& constructed)
 {
-    ContainedPtr contained = ContainedPtr::dynamicCast(_type);
-    if (contained && contained == constructed)
-    {
-	return true;
-    }
-
     return false;
 }
 
-Contained::ContainedType
-Slice::Sequence::containedType()
+Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name) :
+    Contained(container, name),
+    SyntaxTreeBase(container->unit())
 {
-    return ContainedTypeSequence;
 }
 
-void
-Slice::Sequence::visit(ParserVisitor* visitor)
+// ----------------------------------------------------------------------
+// Operation
+// ----------------------------------------------------------------------
+
+TypePtr
+Slice::Operation::returnType()
 {
-    visitor->visitSequence(this);
+    return _returnType;
 }
 
-Slice::Sequence::Sequence(const ContainerPtr& container, const string& name, const TypePtr& type) :
-    Constructed(container, name),
-    Type(container->unit()),
-    Contained(container, name),
-    SyntaxTreeBase(container->unit()),
-    _type(type)
+TypeStringList
+Slice::Operation::inputParameters()
 {
+    return _inParams;
 }
 
-// ----------------------------------------------------------------------
-// Dictionary
-// ----------------------------------------------------------------------
+TypeStringList
+Slice::Operation::outputParameters()
+{
+    return _outParams;
+}
 
-TypePtr
-Slice::Dictionary::keyType()
+ExceptionList
+Slice::Operation::throws()
 {
-    return _keyType;
+    return _throws;
 }
 
-TypePtr
-Slice::Dictionary::valueType()
+bool
+Slice::Operation::nonmutating()
 {
-    return _valueType;
+    return _nonmutating;
+}
+
+Contained::ContainedType
+Slice::Operation::containedType()
+{
+    return ContainedTypeOperation;
 }
 
 bool
-Slice::Dictionary::uses(const ConstructedPtr& constructed)
+Slice::Operation::uses(const ConstructedPtr& constructed)
 {
     {
-	ContainedPtr contained = ContainedPtr::dynamicCast(_keyType);
+	ContainedPtr contained = ContainedPtr::dynamicCast(_returnType);
 	if (contained && contained == constructed)
 	{
 	    return true;
 	}
     }
 
+    TypeStringList::const_iterator p;
+
+    for (p = _inParams.begin(); p != _inParams.end(); ++p)
     {
-	ContainedPtr contained = ContainedPtr::dynamicCast(_valueType);
+	ContainedPtr contained = ContainedPtr::dynamicCast(p->first);
 	if (contained && contained == constructed)
 	{
 	    return true;
 	}
     }
 
-    return false;
-}
+    for (p = _outParams.begin(); p != _outParams.end(); ++p)
+    {
+	ContainedPtr contained = ContainedPtr::dynamicCast(p->first);
+	if (contained && contained == constructed)
+	{
+	    return true;
+	}
+    }
 
-Contained::ContainedType
-Slice::Dictionary::containedType()
-{
-    return ContainedTypeDictionary;
+    ExceptionList::const_iterator q;
+
+    for (q = _throws.begin(); q != _throws.end(); ++q)
+    {
+	ContainedPtr contained = ContainedPtr::dynamicCast(*q);
+	if (contained && contained == constructed)
+	{
+	    return true;
+	}
+    }
+
+    return false;
 }
 
 void
-Slice::Dictionary::visit(ParserVisitor* visitor)
+Slice::Operation::visit(ParserVisitor* visitor)
 {
-    visitor->visitDictionary(this);
+    visitor->visitOperation(this);
 }
 
-Slice::Dictionary::Dictionary(const ContainerPtr& container, const string& name, const TypePtr& keyType,
-			      const TypePtr& valueType) :
-    Constructed(container, name),
-    Type(container->unit()),
+Slice::Operation::Operation(const ContainerPtr& container, const string& name, const TypePtr& returnType,
+			    const TypeStringList& inParams, const TypeStringList& outParams,
+			    const ExceptionList& throws, bool nonmutating) :
     Contained(container, name),
     SyntaxTreeBase(container->unit()),
-    _keyType(keyType),
-    _valueType(valueType)
+    _returnType(returnType),
+    _inParams(inParams),
+    _outParams(outParams),
+    _throws(throws),
+    _nonmutating(nonmutating)
 {
 }
 
 // ----------------------------------------------------------------------
-// Enum
+// DataMember
 // ----------------------------------------------------------------------
 
-EnumeratorList
-Slice::Enum::getEnumerators()
-{
-    return _enumerators;
-}
-
-void
-Slice::Enum::setEnumerators(const EnumeratorList& ens)
-{
-    _enumerators = ens;
-}
-
-bool
-Slice::Enum::uses(const ConstructedPtr& constructed)
+TypePtr
+Slice::DataMember::type()
 {
-    return false;
+    return _type;
 }
 
 Contained::ContainedType
-Slice::Enum::containedType()
-{
-    return ContainedTypeEnum;
-}
-
-void
-Slice::Enum::visit(ParserVisitor* visitor)
-{
-    visitor->visitEnum(this);
-}
-
-Slice::Enum::Enum(const ContainerPtr& container, const string& name) :
-    Constructed(container, name),
-    Type(container->unit()),
-    Contained(container, name),
-    SyntaxTreeBase(container->unit())
+Slice::DataMember::containedType()
 {
+    return ContainedTypeDataMember;
 }
 
-// ----------------------------------------------------------------------
-// Enumerator
-// ----------------------------------------------------------------------
-
 bool
-Slice::Enumerator::uses(const ConstructedPtr& constructed)
+Slice::DataMember::uses(const ConstructedPtr& constructed)
 {
+    ContainedPtr contained = ContainedPtr::dynamicCast(_type);
+    if (contained && contained == constructed)
+    {
+	return true;
+    }
+
     return false;
 }
 
-Contained::ContainedType
-Slice::Enumerator::containedType()
+void
+Slice::DataMember::visit(ParserVisitor* visitor)
 {
-    return ContainedTypeEnumerator;
+    visitor->visitDataMember(this);
 }
 
-Slice::Enumerator::Enumerator(const ContainerPtr& container, const string& name) :
+Slice::DataMember::DataMember(const ContainerPtr& container, const string& name, const TypePtr& type) :
     Contained(container, name),
-    SyntaxTreeBase(container->unit())
+    SyntaxTreeBase(container->unit()),
+    _type(type)
 {
 }