Changeset 828 in dev for trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h

Timestamp:

Mar 19, 2012, 1:59:48 AM (12 years ago)

Author:

イグトランス (egtra)

Message:

egtraブランチの内容をマージ。

Location:

trunk

Files:

• . (modified) (1 prop)
• ab5.0/abdev (modified) (1 prop)
• ab5.0/abdev/ab_common/include/Lexical/Type.h (modified) (8 diffs)

trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h

@@ +1 @@
+#include <boost/foreach.hpp>
 #pragma once
 
@@ -66 +67 @@
       index( (LONG_PTR)&objClass ){}
 
-    Type( const Type &type )
-        : basicType( type.basicType )
-        , index( type.index )
-        , actualGenericTypes( type.actualGenericTypes )
-        , formalTypeName( type.formalTypeName )
-        , formalTypeIndex( type.formalTypeIndex )
+    Type(Type&& type)
+        : basicType(std::move(type.basicType))
+        , index(std::move(type.index))
+        , actualGenericTypes(std::move(type.actualGenericTypes))
+        , formalTypeName(std::move(type.formalTypeName))
+        , formalTypeIndex(std::move(type.formalTypeIndex))
+    {
+    }
+
+    Type(Type const& type)
+        : basicType(type.basicType)
+        , index(type.index)
+        , actualGenericTypes(type.actualGenericTypes)
+        , formalTypeName(type.formalTypeName)
+        , formalTypeIndex(type.formalTypeIndex)
     {
     }
@@ -77 +87 @@
     ~Type();
 
-    void operator= ( const Type &type )
-    {
-        basicType = type.basicType;
-        index = type.index;
-        actualGenericTypes = type.actualGenericTypes;
-        formalTypeName = type.formalTypeName;
-        formalTypeIndex = type.formalTypeIndex;
-    }
-
-    __inline int GetBasicType() const
+    Type& operator =(Type&& type)
+    {
+        basicType = std::move(type.basicType);
+        index = std::move(type.index);
+        actualGenericTypes = std::move(type.actualGenericTypes);
+        formalTypeName = std::move(type.formalTypeName);
+        formalTypeIndex = std::move(type.formalTypeIndex);
+        return *this;
+    }
+
+    Type& operator =(Type const& type)
+    {
+        return *this = Type(type);
+    }
+
+    int GetBasicType() const
     {
         return basicType;
@@ -253 +269 @@
 
 public:
+    Types() {}
+    Types(Types&& y) : std::vector<Type>(std::move(y)) {}
+    Types(Types const& y) : std::vector<Type>(y) {}
+
+    Types& operator =(Types&& y)
+    {
+        std::vector<Type>::operator =(std::move(y));
+        return *this;
+    }
+
+    Types& operator =(Types const& y)
+    {
+        return *this = std::move(Types(y));
+    }
+
     bool IsEquals( const Types &Types ) const;
 };
@@ -281 +312 @@
 
 public:
-    GenericType( const std::string &name, const Type &type )
-        : name( name )
-        , type( type )
-    {
-    }
+    GenericType( std::string name, Type type )
+        : name(std::move(name))
+        , type(std::move(type))
+    {
+    }
+
     GenericType()
     {
     }
+
+    GenericType(GenericType&& y)
+        : name(std::move(y.name))
+        , type(std::move(y.type))
+    {
+    }
+
+    GenericType(GenericType const& y)
+        : name(y.name)
+        , type(y.type)
+    {
+    }
+
+    GenericType& operator =(GenericType&& y)
+    {
+        name = std::move(y.name);
+        type = std::move(y.type);
+        return *this;
+    }
+
+    GenericType& operator =(GenericType const& y)
+    {
+        return *this = std::move(GenericType(y));
+    }
+
     ~GenericType()
     {
@@ -329 +386 @@
     {
     }
+
     BlittableType()
-    {
-    }
+        : basicType()
+        , pClass()
+    {
+    }
+
+    BlittableType(BlittableType&& y)
+        : basicType(std::move(y.basicType))
+        , pClass(std::move(y.pClass))
+    {
+    }
+
+    BlittableType(BlittableType const& y)
+        : basicType(y.basicType)
+        , pClass(y.pClass)
+    {
+    }
+
+    BlittableType& operator =(BlittableType&& y)
+    {
+        basicType = std::move(y.basicType);
+        pClass = std::move(y.pClass);
+        return *this;
+    }
+
+    BlittableType& operator =(BlittableType const& y)
+    {
+        return *this = std::move(BlittableType(y));
+    }
+
     const Type &GetBasicType() const
     {
@@ -344 +429 @@
     virtual bool Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors );
 };
+
 class BlittableTypes : public std::vector<BlittableType>
 {
@@ -358 +444 @@
 
 public:
+    BlittableTypes() {}
+    BlittableTypes(BlittableTypes&& y) : std::vector<BlittableType>(std::move(y)) {}
+    BlittableTypes(BlittableTypes const& y) : std::vector<BlittableType>(y) {}
+    BlittableTypes& operator =(BlittableTypes&& y)
+    {
+        std::vector<BlittableType>::operator =(std::move(y));
+        return *this;
+    }
+    BlittableTypes& operator =(BlittableTypes const& y)
+    {
+        return *this = std::move(BlittableTypes(y));
+    }
+
     bool IsExist( Type type ) const
     {