#pragma once
#pragma once
namespace Generic1 = System::Collections::Generic;
class TestClass
{
public:
TestClass();
~TestClass();
};
public enum class Color {
/// Insert Red summary here
/// F:Mono.DocTest.Color.Red.
Red,
/// Insert Blue summary here
/// F:Mono.DocTest.Color.Blue.
Blue,
/// Insert Green summary here
/// F:Mono.DocTest.Color.Green.
Green,
AnotherGreen = Green,
};
/// T generic param
/// T:Mono.DocTest.IFoo`1.
generic
public interface class IFoo {
/// U generic param
/// T:Mono.DocTest.IFoo`1.Method``1(`0,``0).
generic
T Method(T t, U u);
};
namespace Mono_DocTest_Generic {
using namespace System;
using namespace System::Collections;
generic
where T: value class
public interface class IFooNew {
/// U generic param
/// T:Mono.DocTest.IFoo`1.Method``1(`0,``0).
generic
T Method(T t, U u);
};
/// extension methods!
/// T:Mono.DocTest.Generic.Extensions
//todo: do need attribute on class??
[System::Runtime::CompilerServices::Extension]
public ref class Extensions abstract sealed {
/// System.Object extension method
/// M:Mono.DocTest.Generic.Extensions.ToEnumerable``1
public:
generic
[System::Runtime::CompilerServices::Extension]
static Generic1::IEnumerable ^ ToEnumerable(T self)
{
//todo: no yield
//yield return self;
return gcnew Generic1::List();
};
/// extension method
/// M:Mono.DocTest.Generic.Extensions.ForEach``1
public:
generic
[System::Runtime::CompilerServices::Extension]
static void ForEach(Generic1::IEnumerable ^ self, Action ^ a)
{
};
/// extension method
/// M:Mono.DocTest.Generic.Extensions.Bar``1
public:
generic
[System::Runtime::CompilerServices::Extension]
static void Bar(IFoo^ self, String ^ s)
{
};
///
///
/// extension method.
///
/// M:Mono.DocTest.Generic.Extensions.ToDouble
public:
[System::Runtime::CompilerServices::Extension]
static Generic1::IEnumerable^ ToDouble(Generic1::IEnumerable^ list)
{
return nullptr;
};
///
/// extension method.
///
/// M:Mono.DocTest.Generic.Extensions.ToDouble
public:
generic
where T : IFoo
[System::Runtime::CompilerServices::Extension]
static double ToDouble(T val)
{
// the target type is T:...IFoo, NOT T:System.Object.
return 0.0;
};
};
/// Insert text here.
/// T:Mono.DocTest.Generic.GenericBase`1.
generic
public ref class GenericBase {
/// Something
/// Insert more text here.
/// M:Mono.DocTest.GenericBase`1.BaseMethod``1(``0).
/// The default value.
//todo: done for default keyword
private: U member;
//todo: done for default keyword
public: GenericBase() : member()
{
};
//todo: done for default keyword
GenericBase(GenericBase^ c)
{
member = c->member;
};
public:
generic
U BaseMethod(/*[Doc("S")]*/S genericParameter) {
return member;
};
U BaseMethod2(GenericBase genericParameter) {
return member;
};
/// F:Mono.DocTest.GenericBase`1.StaticField1
public:
static initonly GenericBase ^ StaticField1 = gcnew GenericBase();
/// F:Mono.DocTest.GenericBase`1.ConstField1
public: const int ConstInt = 1;
public: const long ConstLong = 2;
public: const Decimal ConstDecimal;
public: const short ConstShort = 4;
public: const UInt16 ConstUint16 = 2 ;
public: const UInt32 ConstUint32 = 3;
public: const UInt64 ConstUint64 = 4;
public: const float ConstFloat = 2.4;
public: const bool ConstBool = true;
public: const char ConstChar = 't';
public: const Object^ ConstObject;
public: const String^ ConstString;
/// Insert description here
/// M:Mono.DocTest.GenericBase`1.op_Explicit(Mono.DocTest.GenericBase{`0})~`0
/// The default value for .
//public: static explicit operator U(GenericBase list) { /*return 0;*/ return nullptr; };
/// T:Mono.DocTest.Generic.GenericBase`1.FooEventArgs
public: ref class FooEventArgs : EventArgs {
};
/// E:Mono.DocTest.Generic.GenericBase`1.MyEvent
public: event EventHandler ^ MyEvent;
/// E:Mono.DocTest.Generic.GenericBase`1.ItemChanged
//todo: uncomment
//public: event Action^, Mono_DocTest_Generic::MyList::Helper^> ItemChanged;
/// T:Mono.DocTest.Generic.GenericBase`1.NestedCollection
public: ref class NestedCollection {
//todo: no internal
/// T:Mono.DocTest.Generic.GenericBase`1.NestedCollection.Enumerator
protected: value struct Enumerator {
};
};
};
/// I'm Dying Here!
/// T:Mono.DocTest.Generic.MyList`1.
//todo: on generic par-r [Mono.DocTest.Doc("Type Parameter!")]
generic
public ref class MyList : GenericBase, Generic1::IEnumerable ^ >
{
/// Seriously!
/// Too many docs!
/// T:Mono.DocTest.MyList`1.Helper`2.
public:
generic
ref class Helper {
/// Ako
/// bko
/// cko
/// M:Mono.DocTest.MyList`1.Helper`2.UseT(`0,`1,`2).
public: void UseT(T a, U b, V c) { };
};
/// tko
/// M:Mono.DocTest.MyList`1.Test(`0).
public: void Test(T t) { auto a = gcnew MyList::Helper(); };
/// Class generic type
/// Method generic type
/// Method generic parameter
/// M:Mono.DocTest.MyList`1.Method``1(`0,``0).
public:
generic
void Method(T t, U u) {};
// mcs "crashes" (CS1569) on this method; exclude it for now.
// M:Mono.DocTest.MyList`1.RefMethod``1(`0@,``0@).
public:
generic
void RefMethod(T% t, U% u) {};
/// A .
/// Argh!
/// Foo Argh!
/// M:Mono.DocTest.Generic.MyList`1.UseHelper``2(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2}).
public:
generic
void UseHelper(Helper helper) {};
/// M:Mono.DocTest.Generic.MyList`1.GetHelper``2.
/// .
public:
generic
Helper^ GetHelper() { return nullptr; };
/// M:Mono.DocTest.MyList`1.System#Collections#GetEnumerator.
public: virtual IEnumerator^ GetEnumerator1() = IEnumerable::GetEnumerator{
return nullptr;
};
/// M:Mono.DocTest.MyList`1.GetEnumerator.
public: virtual Generic1::IEnumerator^>^ GetEnumerator() = Generic1::IEnumerable^>::GetEnumerator{
return nullptr;
};
};
/// T generic param
/// T:Mono.DocTest.IFoo`1.
generic
public interface class IFoo {
/// U generic param
/// T:Mono.DocTest.IFoo`1.Method``1(`0,``0).
generic
T Method(T t, U u);
};
generic
where T: gcnew()
public ref class GenericConstraintClass {
};
/// Ako generic param
/// Bko generic param
/// T:Mono.DocTest.MyList`2.
generic
//where A : class, IList, gcnew()
//where B : class, A
public ref class MyList1 : Generic1::ICollection,
Generic1::IEnumerable, Generic1::IEnumerator,
IFoo
, GenericBase^ >/*<>*/
{
~MyList1() {};
// IEnumerator
// shown?
//todo: uncomment
//property Object^ IEnumerator::Current { Object^ get() { return nullptr; } }
/// M:Mono.DocTest.MyList`2.MoveNext.
///
public:
virtual bool MoveNext() { return false; };
/// M:Mono.DocTest.MyList`2.Reset.
public:
virtual void Reset() {};
virtual property Object^ Current3 {
Object^ get() = IEnumerator::Current::get{ return nullptr; }
};
// IEnumerator
/// P:Mono.DocTest.MyList`2.Current.
/// The current value.
public:
property A Current1 {
A get() { return Current2; /*default(A);*/ }
};
/// P:Mono.DocTest.MyList`2.Current.
/// The current value.
virtual property A Current2 {
A get() sealed = Generic1::IEnumerator::Current::get{ return Current1; /*default(A);*/ };// { return default(A); }
};
/// M:Mono.DocTest.MyList`2.System#Collections#GetEnumerator.
public: virtual System::Collections::IEnumerator^ GetEnumerator1() = System::Collections::IEnumerable::GetEnumerator{
return nullptr;
};
// IEnumerable
/// M:Mono.DocTest.MyList`2.System#Collections#Generic#IEnumerable{A}#GetEnumerator.
/// A .
virtual Generic1::IEnumerator^ GetEnumerator() = Generic1::IEnumerable::GetEnumerator{ return nullptr; };
public: Generic1::List::Enumerator^ GetEnumerator3() { return gcnew Generic1::List::Enumerator(); };
// ICollection
/// P:Mono.DocTest.MyList`2.Count.
/// A .
public:
virtual property int Count {
int get() { return 0; }
};
/// P:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#IsReadOnly.
/// A .
public:
virtual property bool IsReadOnly {
bool get() { return false; }
};
/// The item to add.
/// M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Add(`0).
virtual void Add(A item) = Generic1::ICollection::Add{};
/// M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Clear.
virtual void Clear() = Generic1::ICollection::Clear{};
/// The item to check for
/// M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}.Contains(`0).
/// A instance ().
virtual bool Contains(A item) = Generic1::ICollection::Contains{ return false; };
/// Where to copy elements to
/// Where to start copyingto
/// M:Mono.DocTest.MyList`2.CopyTo(`0[],System.Int32).
public: virtual void CopyTo(cli::array^ arrayPar, int arrayIndex) = Generic1::ICollection::CopyTo{};
/// the item to remove
/// M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Remove(`0).
/// Whether the item was removed.
virtual bool Remove(A item) = Generic1::ICollection::Remove{ return false; };
/// M:Mono.DocTest.Generic.MyList`2.Foo
public:
generic
where AA : Generic1::IEnumerable
where BB : Generic1::IEnumerable
Generic1::KeyValuePair^ Foo()
{
return gcnew Generic1::KeyValuePair();
};
// IFoo members
/// U generic param on MyList`2
/// M:Mono.DocTest.Generic.MyList`2.Mono#DocTest#Generic#IFoo{A}#Method``1(`0,``0).
generic
virtual A Method(A a, U u) = IFoo::Method
{
return Current2; /*default(A);*/
};
};
}