Types.c

Go to the documentation of this file.

string String(string s)
{
    return s;
}

proto native vector Vector(float x, float y, float z);

class Class
{
    proto native external bool IsInherited(typename type);

    proto native external int GetSizeOf();

    proto native owned external string ClassName();

    proto native external typename Type();
 
    proto external string ToString();

    [Obsolete("Will be removed")]
    proto native external int GetRefCount();

    proto static Class Cast(Class from);

    private proto static void SafeCastType(out typename type, out Class to, Class from);
}
 
class Managed
{
    proto external ref Managed Clone();
}

class ScriptAndConfig: Managed
{
}

class pointer
{
    proto string ToString();
}

class global_pointer: pointer
{
}

class handle64: pointer
{
}
 
class func
{
    private proto void SetInstance(Managed inst);
}

class TypeID: handle64
{
}
 
class array<Class T>: Managed
{
    proto native int Count();

    proto native bool IsEmpty();

    proto native void Clear();

    proto native void Compact();

    proto void Set(int n, T value);

    proto int Find(T value);

    proto bool Contains(T value);

    proto T Get(int n);

    proto int Insert(T value);

    proto int InsertAt(T value, int index);

    void InsertAll(notnull array<T> from)
    {
        for ( int i = 0; i < from.Count(); i++ )
        {
            Insert( from.Get(i) );
        }
    }

    proto native void Remove(int index);

    proto native void RemoveOrdered(int index);

    proto native void Resize(int newSize);

    proto native void Reserve(int newSize);

    proto native void Swap(notnull array<T> other);

    proto native void Sort(bool reverse = false);

    proto native bool IsIndexValid(int index);

    proto int Copy(notnull array<T> from);
 
    proto int Init(T init[]);

    proto bool RemoveItem(T value);

    proto bool RemoveItemOrdered(T value);

    void Debug()
    {
        PrintFormat( "Array count: %1", Count());
 
        for ( int i = 0; i < Count(); i++ )
        {
            T item = Get(i);
 
            PrintFormat("[%1] => %2", i, string.ToString(item));
        }
    }

    int GetRandomIndex()
    {
        if ( Count() > 0 )
        {
            return Math.RandomInt(0, Count());
        }
 
        return -1;
    }

    T GetRandomElement()
    {
        return Get(GetRandomIndex());
    }
 
    void SwapItems(int item1_index, int item2_index)
    {
        T item1 = Get(item1_index);
        Set(item1_index, Get(item2_index));
        Set(item2_index, item1);
    }
}
 
//force these to compile so we can link C++ methods to them
typedef array<string> TStringArray;
typedef array<float> TFloatArray;
typedef array<int> TIntArray;
typedef array<bool> TBoolArray;
typedef array<Class> TClassArray;
typedef array<Managed> TManagedArray;
typedef array<ref Managed> TManagedRefArray;
typedef array<vector> TVectorArray;
typedef array<pointer> TPointerArray;
typedef array<ResourceName> TResourceNameArray;
 
class set<Class T>: Managed
{
    proto native int Count();
    proto native bool IsEmpty();
    proto native void Clear();
    proto native void Compact();
    proto native void Reserve(int newSize);
    proto int Find(T value);
    proto bool Contains(T value);
    proto T Get(int n);
    proto bool Insert(T value);
    proto native void Remove(int index);
    
    proto bool RemoveItem(T value);
    
    proto native bool IsIndexValid(int index);
 
    proto int Copy(set<T> from);
    proto native void Swap(set<T> other);
    proto int Init(T init[]);
}
 
//force these to compile so we can link C++ methods to them
typedef set<string> TStringSet;
typedef set<float> TFloatSet;
typedef set<int> TIntSet;
typedef set<Class> TClassSet;
typedef set<Managed> TManagedSet;
typedef set<ref Managed> TManagedRefSet;
typedef set<pointer> TPointerSet;
 
typedef int MapIterator;

class map<Class TKey,Class TValue>: Managed
{
    proto native int Count();

    proto native bool IsEmpty();

    proto native void Clear();

    proto TValue Get(TKey key);
    proto bool Find(TKey key, out TValue val);
    proto TValue GetElement(int index);
    proto TKey GetKey(int i);
    proto void Set(TKey key, TValue value);
    /*
    Removes element with given `key`.
    \return `true` if element was removed.
    */
    proto bool Remove(TKey key);
    proto bool Take(TKey key, out TValue value);
    proto bool RemoveElement(int i);
    proto bool Contains(TKey key);
    proto bool Insert(TKey key, TValue value);
    proto int Copy(map<TKey,TValue> from);
 
    [Obsolete("Use SCR_MapHelper.ReplaceKey")]
    bool ReplaceKey(TKey old_key, TKey new_key)
    {
        if (Contains(old_key))
        {
            Set(new_key, Get(old_key));
            Remove(old_key);
            return true;
        }
        return false;
    }
    
    [Obsolete("Use SCR_MapHelper.GetKeyByValue")]
    TKey GetKeyByValue(TValue value)
    {
        TKey ret;
        for (int i = 0; i < Count(); i++)
        {
            if (GetElement(i) == value)
            {
                ret = GetKey(i);
                break;
            }
        }
 
        return ret;
    }
 
    proto native MapIterator Begin();
    proto native MapIterator End();
    proto native MapIterator Next(MapIterator it);
    proto TKey GetIteratorKey(MapIterator it);
    proto TValue GetIteratorElement(MapIterator it);
}
 
typedef map<int, float>             TIntFloatMap;
typedef map<int, int>                   TIntIntMap;
typedef map<int, string>            TIntStringMap;
typedef map<int, Class>             TIntClassMap;
typedef map<int, Managed>           TIntManagedMap;
typedef map<int, ref Managed>   TIntManagedRefMap;
typedef map<int, pointer>       TIntPointerMap;
typedef map<int, vector>            TIntVectorMap;
 
typedef map<string, float>      TStringFloatMap;
typedef map<string, int>            TStringIntMap;
typedef map<string, string>     TStringStringMap;
typedef map<string, Class>      TStringClassMap;
typedef map<string, Managed>    TStringManagedMap;
typedef map<string, ref Managed>    TStringManagedRefMap;
typedef map<string, pointer>    TStringPointerMap;
typedef map<string, vector>     TStringVectorMap;
 
typedef map<Class, float>       TClassFloatMap;
typedef map<Class, int>         TClassIntMap;
typedef map<Class, string>      TClassStringMap;
typedef map<Class, Class>       TClassClassMap;
typedef map<Class, Managed>     TClassManagedMap;
typedef map<Class, ref Managed>     TClassManagedRefMap;
typedef map<Class, pointer> TClassPointerMap;
typedef map<Class, vector>      TClassVectorMap;
 
typedef map<pointer, float>     TPointerFloatMap;
typedef map<pointer, int>           TPointerIntMap;
typedef map<pointer, string>        TPointerStringMap;
typedef map<pointer, Class>     TPointerClassMap;
typedef map<pointer, Managed>       TPointerManagedMap;
typedef map<pointer, ref Managed>   TPointerManagedRefMap;
typedef map<pointer, pointer>       TPointerPointerMap;
typedef map<pointer, vector>        TPointerVectorMap;
 
typedef map<Managed, float>     TManagedFloatMap;
typedef map<Managed, int>       TManagedIntMap;
typedef map<Managed, string>    TManagedStringMap;
typedef map<Managed, Class>     TManagedClassMap;
typedef map<Managed, Managed>   TManagedManagedMap;
typedef map<Managed, ref Managed>   TManagedManagedRefMap;
typedef map<Managed, pointer>   TManagedPointerMap;
typedef map<Managed, vector>    TManagedVectorMap;
 
typedef map<ref Managed, float> TManagedRefFloatMap;
typedef map<ref Managed, int>       TManagedRefIntMap;
typedef map<ref Managed, string>    TManagedRefStringMap;
typedef map<ref Managed, Class>     TManagedRefClassMap;
typedef map<ref Managed, Managed>   TManagedRefManagedMap;
typedef map<ref Managed, ref Managed>   TManagedRefManagedRefMap;
typedef map<ref Managed, pointer>   TManagedRefPointerMap;
typedef map<ref Managed, vector>    TManagedRefVectorMap;