public ChatClient()
{
chatTranslation = ChatTranslations.Get();
clientScope = new Scope<object>();
clientScope.Add(ChatConstants.ChatUpdateLisener, this);
_client = new WebSocketOODSSClient(ServerAddress, PortNumber, chatTranslation, clientScope);
}
public static async Task<MetaMetadataRepository> ReadDirectoryRecursively(MetaMetadataRepository mainRepo, String path, SimplTypesScope mmdTScope, SimplTypesScope metadataTScope)
{
Stack<string> stack = new Stack<string>();
stack.Push(path);
while(stack.Count > 0)
{
string dir = stack.Pop();
Debug.WriteLine("Looking in : " + dir);
//String[] files = Directory.GetFiles(dir, "*.xml");
string[] files = await FundamentalPlatformSpecifics.Get().GetFilesFromDirectory(dir, ".xml");
foreach (string file in files)
{
MetaMetadataRepository thatRepo = await ReadRepository(file, mmdTScope, metadataTScope, mainRepo);
// if (thatRepo != null)
// mainRepo.IntegrateRepository(thatRepo);
//string[] directories = Directory.GetDirectories(dir);
// string[] directories = await FundamentalPlatformSpecifics.Get().GetDirectoriesFromDirectory(dir);
// foreach (
// string innerDir in directories.Where(
// innerDir =>
// !innerDir.Contains(".svn")))
// stack.Push(innerDir);
// });
}
}
return mainRepo;
}
public static SimplTypesScope ComposeTranslations(Type[] newTranslations,
int portNumber, IPAddress ipAddress, SimplTypesScope requestTranslationSpace,
String prefix = "server_base: ")
{
return SimplTypesScope.Get(prefix + ipAddress + ":" + portNumber, requestTranslationSpace,
newTranslations);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static SimplTypesScope Lookup(String name)
{
SimplTypesScope result = null;
allTranslationScopes.TryGetValue(name, out result);
return(result);
}
public static void Main(string[] args)
{
Book abook = new Book();
//Here's an instance of our type to serialize
abook.setAuthorName("Michael Feathers");
abook.setBookID(1337);
abook.setTitle("Working Effectively with Legacy Code");
//
//
SimplTypesScope book_example_sts = new SimplTypesScope("book_example", typeof(Book));
//Serialize to JSON
String jsonResult = SimplTypesScope.Serialize(abook, StringFormat.Json);
//Serialize to XML
// (Just change the StringFormat parameter!)
String xmlResult = SimplTypesScope.Serialize(abook, StringFormat.Xml);
Object result1 = book_example_sts.Deserialize(jsonResult, StringFormat.Json);
Book r1 = (Book) result1;
Object result2 = book_example_sts.Deserialize(xmlResult, StringFormat.Xml);
Book r2 = (Book) result2;
Console.WriteLine(jsonResult);
Console.WriteLine(xmlResult);
Console.ReadLine();
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
public SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope)
: this(name)
{
AddTranslations(inheritedSimplTypesScope);
SimplTypesScope[] _inheritedSimplTypesScopes = new SimplTypesScope[1];
_inheritedSimplTypesScopes[0] = inheritedSimplTypesScope;
this._inheritedSimplTypesScopes = _inheritedSimplTypesScopes;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
public SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope)
: this(name)
{
AddTranslations(inheritedSimplTypesScope);
SimplTypesScope[] _inheritedSimplTypesScopes = new SimplTypesScope[1];
_inheritedSimplTypesScopes[0] = inheritedSimplTypesScope;
this._inheritedSimplTypesScopes = _inheritedSimplTypesScopes;
}
/// <summary>
/// Creates an instance of an NIOServer of some flavor. Creates the backend using the information
/// in the arguments.
/// Registers itself as the MAIN_START_AND_STOPPABLE in the object registry.
/// </summary>
/// <param name="portNumber"></param>
/// <param name="ipAddresses"></param>
/// <param name="requestTranslationScope"></param>
/// <param name="objectRegistry"></param>
/// <param name="idleConnectionTimeout"></param>
/// <param name="maxMessageLength"></param>
protected AbstractServer(int portNumber, IPAddress[] ipAddresses,
SimplTypesScope requestTranslationScope, Scope<object> objectRegistry, int idleConnectionTimeout=-1,
int maxMessageLength=-1)
{
Console.WriteLine("setting up server...");
TranslationScope = requestTranslationScope;
ApplicationObjectScope = objectRegistry;
}
public TestServiceClient(string serviceAddress, int port)
{
_serviceAddress = serviceAddress;
_port = port;
_testTypesScope = TestClientTypesScope.Get();
_clientScope = new Scope<object>();
_clientScope.Add(TestServiceConstants.ServiceUpdateListener, this);
_client = new WebSocketOODSSClient(_serviceAddress, _port, _testTypesScope, _clientScope);
}
public SemanticsSessionScope(SimplTypesScope metadataTranslationScope, string repoLocation, ParsedUri serviceUri,
EventHandler<EventArgs> onCompleted)
: base(metadataTranslationScope, repoLocation, onCompleted)
{
SemanticsSessionScope.Get = this;
MetadataServiceUri = serviceUri;
HttpClient = new HttpClient();
}
public BaseSessionManager(string sessionId, SimplTypesScope translationScope, Scope<object> applicationObjectScope, ServerProcessor frontend)
{
FrontEnd = frontend;
SessionId = sessionId;
TranslationScope = translationScope;
LocalScope = GenerateContextScope(applicationObjectScope);
LocalScope.Add(SessionObjects.SessionId, sessionId);
LocalScope.Add(SessionObjects.ClientManager, this);
}
public static SimplTypesScope Get(string name, SimplTypesScope[] inheritedScopes, params Type[] translations)
{
SimplTypesScope result = null;
if (!allTranslationScopes.TryGetValue(name, out result))
{
result = new SimplTypesScope(name, inheritedScopes, translations);
}
return(result);
}
// background working thread
#endregion WebSocketComponent
#region Constructor
/// <summary>
/// Initialze a websocket OODSS client object
/// </summary>
/// <param name="ipAddress">server's ip address</param>
/// <param name="portNumber">server's port number</param>
/// <param name="translationScope">TranslationScope for OODSS messages</param>
/// <param name="objectRegistry">application object scope</param>
public WebSocketOODSSClient(String ipAddress, int portNumber, SimplTypesScope translationScope,
Scope<object> objectRegistry)
{
ObjectRegistry = objectRegistry;
TranslationScope = translationScope;
ObjectRegistry.Add(SessionObjects.SessionId, _sessionId);
ServerAddress = ipAddress;
PortNumber = portNumber;
_pendingRequests = new ConcurrentDictionary<long, RequestQueueObject>();
_requestQueue = new BlockingCollection<RequestQueueObject>(new ConcurrentQueue<RequestQueueObject>());
_responseQueue = new BlockingCollection<ResponseQueueObject>(new ConcurrentQueue<ResponseQueueObject>());
}
private bool ResolveScopeAnnotation(string scopeAnnotation)
{
SimplTypesScope scope = SimplTypesScope.Get(scopeAnnotation);
if (scope != null)
{
List <ClassDescriptor> scopeClassDescriptors = scope.GetClassDescriptors();
InitTagClassDescriptorsArrayList(scopeClassDescriptors.Count);
foreach (ClassDescriptor classDescriptor in scopeClassDescriptors)
{
String tagName = classDescriptor.TagName;
polymorphClassDescriptors.Put(tagName, classDescriptor);
polymorphClasses.Put(tagName, classDescriptor.DescribedClass);
}
}
return(scope != null);
}
/// <summary>
/// Initialize a websocket oodss server object
/// </summary>
/// <param name="serverTranslationScope">translationscope for the oodss messages</param>
/// <param name="applicationObjectScope">server object scope</param>
/// <param name="idleConnectionTimeout"></param>
/// <param name="maxMessageSize"></param>
public WebSocketOODSSServer(SimplTypesScope serverTranslationScope, Scope<object> applicationObjectScope,
int idleConnectionTimeout=-1, int maxMessageSize=-1, int port=0)
: base(port, Dns.GetHostAddresses(Dns.GetHostName()), serverTranslationScope, applicationObjectScope,
idleConnectionTimeout, maxMessageSize)
{
MaxMessageSize = maxMessageSize + NetworkConstants.MaxHttpHeaderLength;
TranslationScope = serverTranslationScope;
ApplicationObjectScope = applicationObjectScope;
ApplicationObjectScope.Add(SessionObjects.SessionsMap, ClientSessionManagerMap);
ApplicationObjectScope.Add(SessionObjects.WebSocketOODSSServer, this);
_serverInstance = this;
SetUpWebSocketServer(port);
}
private bool ResolveScopeAttribute(string scopeAttributeValue)
{
SimplTypesScope scope = SimplTypesScope.Get(scopeAttributeValue);
if (scope != null)
{
List <ClassDescriptor> scopeClassDescriptors = scope.ClassDescriptors;
InitPolymorphicClassDescriptorsList(scopeClassDescriptors.Count);
foreach (var scopeClassDescriptor in scopeClassDescriptors)
{
polymorphClassDescriptors.Put(scopeClassDescriptor.TagName, scopeClassDescriptor);
polymorphClasses.Put(scopeClassDescriptor.TagName, scopeClassDescriptor.DescribedClass);
tlvClassDescriptors.Put(_tagName.GetHashCode(), scopeClassDescriptor);
}
}
return(scope != null);
}
public MetadataServicesClient(SimplTypesScope metadatascope, SemanticsSessionScope semanticSessionScope, ParsedUri serviceUri, bool useWebSockets = false)
{
SimplTypesScope[] oodssAndMetadataScope = {metadatascope, DefaultServicesTranslations.Get()};
_metadataTypeScope = SimplTypesScope.Get("MetadataServicesTranslationScope",
oodssAndMetadataScope,
typeof (MetadataRequest),
typeof (MetadataResponse),
typeof (SemanticServiceError)
);
_serviceBaseUri = serviceUri;
if (useWebSockets)
{
_metadataClient = new WebSocketOODSSClient("127.0.0.1", 2018, _metadataTypeScope, semanticSessionScope);
_metadataClient.StartAsync();
}
}
public OODSSClient(String host, int port, SimplTypesScope simplTypesScope, Scope<object> objectRegistry)
{
_sendMesssageThread = new Thread(SendMessageWorker);
_receiveMesssageThread = new Thread(ReceiveMessageWorker);
_pendingRequests = new ConcurrentDictionary<int, QueueObject>();
_requestQueue = new BlockingCollection<QueueObject>(new ConcurrentQueue<QueueObject>());
Host = host;
Port = port;
ObjectRegistry = objectRegistry;
//Add the OODSS messages to the scope.
simplTypesScope.AddTranslations(ServicesTranslationScope);
SimplTypesScope = simplTypesScope;
var initState = new InitConnectionRequest();
int uid = _uid;
QueueObject q = new QueueObject(initState, uid, null);
_requestQueue.Add(q);
}
public void TestMethod1()
{
Book abook = new Book();
//Here's an instance of our type to serialize
abook.initBook();
//
//
SimplTypesScope book_example_sts = new SimplTypesScope("book_example", typeof(Book));
//Serialize to JSON
String jsonResult = SimplTypesScope.Serialize(abook, StringFormat.Json);
//Serialize to XML
// (Just change the StringFormat parameter!)
String xmlResult = SimplTypesScope.Serialize(abook, StringFormat.Xml);
Object result1 = book_example_sts.Deserialize(jsonResult, StringFormat.Json);
Book r1 = (Book)result1;
Object result2 = book_example_sts.Deserialize(xmlResult, StringFormat.Xml);
Book r2 = (Book)result2;
Assert.IsTrue(result1.GetType().IsAssignableFrom(abook.GetType()));
Assert.AreEqual(r1.getAuthor(), abook.getAuthor());
Assert.AreEqual(r1.getBookID(), abook.getBookID());
Assert.AreEqual(r1.getTitle(), abook.getTitle());
Assert.AreEqual(r1.getAuthor(), "Michael Feathers");
Assert.AreEqual(r1.getBookID(), 1337);
Assert.AreEqual(r1.getTitle(), "Working Effectively with Legacy Code");
Assert.AreEqual(r2.getAuthor(), abook.getAuthor());
Assert.AreEqual(r2.getBookID(), abook.getBookID());
Assert.AreEqual(r2.getTitle(), abook.getTitle());
}
public SimplTypesScope GetSubtractedSubset(string newName, Type superClassCriterion)
{
SimplTypesScope result = Lookup(newName);
if (result == null)
{
result = Lookup(newName);
if (result == null)
{
result = new SimplTypesScope(newName);
AddTranslationScope(newName);
foreach (ClassDescriptor classDescriptor in EntriesByClassName.Values)
{
Type thatClass = classDescriptor.DescribedClass;
if (!superClassCriterion.GetTypeInfo().IsAssignableFrom(thatClass.GetTypeInfo()))
{
result.AddTranslation(thatClass);
}
}
}
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="inheritedSimplTypesScope"></param>
public void AddTranslations(SimplTypesScope inheritedSimplTypesScope)
{
if (inheritedSimplTypesScope != null)
{
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByClassSimpleName, EntriesByClassSimpleName, "classSimpleName");
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByClassName, EntriesByClassName, "className");
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByTag, EntriesByTag, "tagName");
Dictionary <string, Type> inheritedNameSpaceClassesByURN = inheritedSimplTypesScope.nameSpaceClassesByURN;
if (inheritedNameSpaceClassesByURN != null)
{
foreach (String urn in inheritedNameSpaceClassesByURN.Keys)
{
Type valueToAdd = null;
if (inheritedNameSpaceClassesByURN.TryGetValue(urn, out valueToAdd))
{
nameSpaceClassesByURN.Add(urn, valueToAdd);
}
}
}
}
}
internal override bool GetClassAndBindDescriptors(SimplTypesScope metadataTScope)
{
return GetChildComposite().GetClassAndBindDescriptors(metadataTScope);
}
protected internal override MetadataClassDescriptor BindMetadataClassDescriptor(SimplTypesScope metadataTScope)
{
MetaMetadataCompositeField childComposite = GetChildComposite();
if (childComposite != null)
return childComposite.BindMetadataClassDescriptor(metadataTScope);
return null;
}
public SimplTypesScope GetSubtractedSubset(string newName, Type superClassCriterion)
{
SimplTypesScope result = Lookup(newName);
if (result == null)
{
result = Lookup(newName);
if (result == null)
{
result = new SimplTypesScope(newName);
AddTranslationScope(newName);
foreach (ClassDescriptor classDescriptor in EntriesByClassName.Values)
{
Type thatClass = classDescriptor.DescribedClass;
if (!superClassCriterion.GetTypeInfo().IsAssignableFrom(thatClass.GetTypeInfo()))
result.AddTranslation(thatClass);
}
}
}
return result;
}
/// <summary>
///
/// </summary>
/// <param name="inheritedSimplTypesScope"></param>
public void AddTranslations(SimplTypesScope inheritedSimplTypesScope)
{
if (inheritedSimplTypesScope != null)
{
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByClassSimpleName, EntriesByClassSimpleName, "classSimpleName");
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByClassName, EntriesByClassName, "className");
UpdateMapWithValues(inheritedSimplTypesScope.EntriesByTag, EntriesByTag, "tagName");
Dictionary<string, Type> inheritedNameSpaceClassesByURN = inheritedSimplTypesScope.nameSpaceClassesByURN;
if (inheritedNameSpaceClassesByURN != null)
{
foreach (String urn in inheritedNameSpaceClassesByURN.Keys)
{
Type valueToAdd = null;
if (inheritedNameSpaceClassesByURN.TryGetValue(urn, out valueToAdd))
nameSpaceClassesByURN.Add(urn, valueToAdd);
}
}
}
}
public static SimplTypesScope Get(string name, SimplTypesScope[] inheritedScopes, params Type[] translations)
{
SimplTypesScope result = null;
if (!allTranslationScopes.TryGetValue(name, out result))
{
result = new SimplTypesScope(name, inheritedScopes, translations);
}
return result;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
/// <param name="translation"></param>
public SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope, Type translation)
: this(name, inheritedSimplTypesScope)
{
AddTranslation(translation);
AddTranslationScope(name);
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
/// <param name="translations"></param>
private SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope, Type[] translations)
: this(name, inheritedSimplTypesScope)
{
AddTranslations(translations);
AddTranslationScope(name);
}
public SemanticsGlobalScope(SimplTypesScope metadataTranslationScope, string repoLocation, EventHandler<EventArgs> onCompleted) : base(metadataTranslationScope, repoLocation, onCompleted)
{
_globalDocumentCollection = new SemanticsGlobalCollection<Document>();
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="_inheritedSimplTypesScopes"></param>
/// <param name="translations"></param>
public SimplTypesScope(String name, SimplTypesScope[] _inheritedSimplTypesScopes, Type[] translations)
: this(name, _inheritedSimplTypesScopes)
{
AddTranslations(translations);
AddTranslationScope(name);
}
protected override void CustomizeFieldDescriptor(SimplTypesScope metadataTScope, MetadataFieldDescriptorProxy fdProxy)
{
base.CustomizeFieldDescriptor(metadataTScope, fdProxy);
fdProxy.SetCollectionOrMapTagName(ChildTag);
fdProxy.SetWrapped(!NoWrap);
}
protected abstract BaseSessionManager GenerateContextManager(string seesionId,
SimplTypesScope translationScope,
Scope<Object> globalScope);
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
/// <param name="translations"></param>
private SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope, Type[] translations)
: this(name, inheritedSimplTypesScope)
{
AddTranslations(translations);
AddTranslationScope(name);
}
public static SimplTypesScope ComposeTranslations(int portNumber, IPAddress ipAddress,
SimplTypesScope requestTranslationSpace)
{
return ComposeTranslations(_ourTranslation, portNumber, ipAddress, requestTranslationSpace);
}
protected AbstractServer(int portNumber, IPAddress ipAddress, SimplTypesScope requestTranslationSpace,
Scope<object> objectRegistry, int idleConnectionTimeout, int maxMessageLength)
: this(portNumber, new[]{ipAddress}, requestTranslationSpace,
objectRegistry, idleConnectionTimeout, maxMessageLength)
{
}
public void SimplPolymorphicCompositeFollowsTagNameConventions()
{
// case A: We have an ITC in the polymorphic class
// Create the object
var ourObjCaseA = new InternalPolymorphicCompositeTestClass(4, true);
// Make sure that we created it correctly
Assert.IsTrue(ourObjCaseA.polyMorph.GetType().Equals(typeof(InternalTestClass)), "Type should be internalTestClass");
// Create the sts
var ourSTS = new SimplTypesScope("CompositeWithPolymorph", new[] { typeof(InternalTestClass), typeof(InternalCompositeTestClass), typeof(InternalPolymorphicCompositeTestClass) });
// Serialize it, get the XML representation, parse it
var resultStream = TestMethods.TestSerialization(ourObjCaseA, Format.Xml);
string xmlString = resultStream.StringData;
XElement xe = XElement.Parse(xmlString);
// polyMorph => poly_morph. And we should expect that element in our serialized representation.
Assert.IsTrue(xe.Elements("poly_morph").Any(), "Should have an XML composite element \"poly_morph\"");
// Okay, let's do case B, an Internal Composite inside. ;D
var ourObjCaseB = new InternalPolymorphicCompositeTestClass(5, false);
// Yes, I know this could probably be a seperate method. Just putting it here beacuse it fit in the moment.
// Feel free to refactor if it tickles your fancy as such.
// Serialize it, get the XML representation, parse it
var resultStreamCaseB = TestMethods.TestSerialization(ourObjCaseB, Format.Xml);
string xmlStringCaseB = resultStreamCaseB.StringData;
XElement xeCaseB = XElement.Parse(xmlStringCaseB);
// polyMorph => poly_morph. And we should expect that element in our serialized representation.
Assert.IsTrue(xeCaseB.Elements("poly_morph").Any(), "Should have an XML composite element \"poly_morph\"");
// We'll defer these tests to the end; if we have a failure earlier we'll end up getting a deserialized null
// because we fail hard if we don't serialize the type name correctly.
TestMethods.TestSimplObject(ourObjCaseA, ourSTS);
TestMethods.TestSimplObject(ourObjCaseB, ourSTS);
}
public WebSocketClientSessionManager(string sessionId, SimplTypesScope translationScope, Scope<object> applicationObjectScope, ServerProcessor frontend)
: base(sessionId, translationScope , applicationObjectScope, frontend)
{
}
public async static Task<SemanticsSessionScope> InitAsync(SimplTypesScope metadataTranslationScope, string repoLocation, ParsedUri serviceUri)
{
var scope = await Task.Run(() => new SemanticsSessionScope(metadataTranslationScope, repoLocation, serviceUri, null));
return scope;
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="inheritedSimplTypesScope"></param>
/// <param name="translation"></param>
public SimplTypesScope(String name, SimplTypesScope inheritedSimplTypesScope, Type translation)
: this(name, inheritedSimplTypesScope)
{
AddTranslation(translation);
AddTranslationScope(name);
}