public void TestPofExtractorWithValueChangeEventFilter2()
        {
            // Testing on remote cache using Address, which is defined on
            // Java side.
            INamedCache cache = CacheFactory.GetCache(CacheName);

            cache.Clear();

            Hashtable ht       = new Hashtable();
            Address   address1 = new Address("Street1", "City1", "State1", "Zip1");
            Address   address2 = new Address("Street2", "City2", "State2", "Zip2");

            ht.Add("key1", address1);
            ht.Add("key2", address2);
            cache.InsertAll(ht);

            SyncListener listener = new SyncListener();
            IFilter      filter   = new ValueChangeEventFilter(new PofExtractor(typeof(String), 0));

            cache.AddCacheListener(listener,
                                   filter,
                                   false);
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new Address("Street1", "City1a", "State1a", "Zip1a");
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new Address("Street1a", "City1", "State1", "Zip1");
            Assert.IsNotNull(listener.CacheEvent);

            CacheFactory.Shutdown();
        }
        public void TestPofExtractorWithValueChangeEventFilter1()
        {
            // Testing on remote cache using CustomerKeyClass, which is not
            // defined on Java side
            INamedCache cache = CacheFactory.GetCache(CacheName);

            cache.Clear();

            // CustomerKeyClass is not defined on the Java side
            //
            Hashtable      ht   = new Hashtable();
            CustomKeyClass key1 = new CustomKeyClass("Customer1");
            CustomKeyClass key2 = new CustomKeyClass("Customer2");

            ht.Add("key1", key1);
            ht.Add("key2", key2);
            cache.InsertAll(ht);

            SyncListener listener = new SyncListener();
            IFilter      filter   = new ValueChangeEventFilter(new PofExtractor(typeof(String), 0));

            cache.AddCacheListener(listener,
                                   filter,
                                   false);
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new CustomKeyClass("Customer1");
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new CustomKeyClass("Customer12");
            Assert.IsNotNull(listener.CacheEvent);

            CacheFactory.Shutdown();
        }
        public void TestExtractorEventTransformer()
        {
            //testing on remote cache
            INamedCache cache = CacheFactory.GetCache(CacheName);

            cache.Clear();

            Hashtable ht       = new Hashtable();
            Address   address1 = new Address("Street1", "City1", "State1", "Zip1");
            Address   address2 = new Address("Street2", "City2", "State2", "Zip2");

            ht.Add("key1", address1);
            ht.Add("key2", address2);
            cache.InsertAll(ht);

            SyncListener           listener    = new SyncListener();
            IFilter                filter      = new ValueChangeEventFilter("getStreet");
            IValueExtractor        extractor   = IdentityExtractor.Instance;
            ICacheEventTransformer transformer = new ExtractorEventTransformer(null, extractor);

            cache.AddCacheListener(listener,
                                   new CacheEventTransformerFilter(filter,
                                                                   transformer),
                                   false);
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new Address("Street1", "City1a", "State1a", "Zip1a");
            Assert.IsNull(listener.CacheEvent);

            cache["key1"] = new Address("Street1a", "City1a", "State1a", "Zip1a");
            Assert.IsNotNull(listener.CacheEvent);

            CacheFactory.Shutdown();
        }
Exemplo n.º 4
0
        public void setHeaders()
        {          
            _log.Debug("Running: setHeaders");
            IClientSession ssn = Client.CreateSession(0);
            ssn.QueueDeclare("queue1");
            ssn.ExchangeBind("queue1", "amq.direct", "queue1");
            ssn.Sync();
            CircularBuffer<IMessage> buff = new CircularBuffer<IMessage>(10); 
            SyncListener listener = new SyncListener(ssn, buff);
            ssn.AttachMessageListener(listener, "queue1");
            ssn.MessageSubscribe("queue1");

            IMessage message = new org.apache.qpid.client.Message();
            message.DeliveryProperties.SetRoutingKey("queue1");
            const long someLong = 14444444;
            message.ApplicationHeaders.Add("someLong", someLong);
            const int someInt = 14;
            message.ApplicationHeaders.Add("soneInt", someInt);
            const float someFloat = 14.001F;
            message.ApplicationHeaders.Add("soneFloat", someFloat);
            const double someDouble = 14.5555555;
            message.ApplicationHeaders.Add("someDouble", someDouble);
            const byte someByte = 2;
            message.ApplicationHeaders.Add("someByte", someByte);
            const string someString = "someString";
            message.ApplicationHeaders.Add("someString", someString);
            const char someChar = 'a';
            message.ApplicationHeaders.Add("someChar", someChar);
            const Boolean someBoolean = true;
            message.ApplicationHeaders.Add("someBoolean", someBoolean);

            // transfer the message 
            ssn.MessageTransfer("amq.direct", message); 

            // get the message and check the headers 
            IMessage messageBack = buff.Dequeue();
            Assert.IsTrue(((string) messageBack.ApplicationHeaders["someString"]).Equals(someString));
            Assert.IsTrue(((char)messageBack.ApplicationHeaders["someChar"]).Equals(someChar));
            Assert.IsTrue((long)messageBack.ApplicationHeaders["someLong"] == someLong);
            Assert.IsTrue((int)messageBack.ApplicationHeaders["soneInt"] == someInt);           
            Assert.IsTrue((double)messageBack.ApplicationHeaders["someDouble"] == someDouble);
            Assert.IsTrue((byte) messageBack.ApplicationHeaders["someByte"] == someByte);
            Assert.IsTrue((Boolean)messageBack.ApplicationHeaders["someBoolean"]);
            // c# has an conversion precision issue with decimal 
            Assert.IsTrue((float) messageBack.ApplicationHeaders["soneFloat"] <= someFloat);
            float b = (float) messageBack.ApplicationHeaders["soneFloat"];
            Assert.IsTrue(Convert.ToInt32(b) == Convert.ToInt32(someFloat));
        }
Exemplo n.º 5
0
 internal static System.Runtime.InteropServices.HandleRef getCPtr(SyncListener obj)
 {
     return((obj == null) ? new System.Runtime.InteropServices.HandleRef(null, System.IntPtr.Zero) : obj.swigCPtr);
 }
 internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SyncListener obj) {
   return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 }
Exemplo n.º 7
0
        public void setHeaders()
        {
            _log.Debug("Running: setHeaders");
            IClientSession ssn = Client.CreateSession(0);

            ssn.QueueDeclare("queue1");
            ssn.ExchangeBind("queue1", "amq.direct", "queue1");
            ssn.Sync();
            CircularBuffer <IMessage> buff = new CircularBuffer <IMessage>(10);
            SyncListener listener          = new SyncListener(ssn, buff);

            ssn.AttachMessageListener(listener, "queue1");
            ssn.MessageSubscribe("queue1");

            IMessage message = new org.apache.qpid.client.Message();

            message.DeliveryProperties.SetRoutingKey("queue1");
            const long someLong = 14444444;

            message.ApplicationHeaders.Add("someLong", someLong);
            const int someInt = 14;

            message.ApplicationHeaders.Add("soneInt", someInt);
            const float someFloat = 14.001F;

            message.ApplicationHeaders.Add("soneFloat", someFloat);
            const double someDouble = 14.5555555;

            message.ApplicationHeaders.Add("someDouble", someDouble);
            const byte someByte = 2;

            message.ApplicationHeaders.Add("someByte", someByte);
            const string someString = "someString";

            message.ApplicationHeaders.Add("someString", someString);
            const char someChar = 'a';

            message.ApplicationHeaders.Add("someChar", someChar);
            const Boolean someBoolean = true;

            message.ApplicationHeaders.Add("someBoolean", someBoolean);

            // transfer the message
            ssn.MessageTransfer("amq.direct", message);

            // get the message and check the headers
            IMessage messageBack = buff.Dequeue();

            Assert.IsTrue(((string)messageBack.ApplicationHeaders["someString"]).Equals(someString));
            Assert.IsTrue(((char)messageBack.ApplicationHeaders["someChar"]).Equals(someChar));
            Assert.IsTrue((long)messageBack.ApplicationHeaders["someLong"] == someLong);
            Assert.IsTrue((int)messageBack.ApplicationHeaders["soneInt"] == someInt);
            Assert.IsTrue((double)messageBack.ApplicationHeaders["someDouble"] == someDouble);
            Assert.IsTrue((byte)messageBack.ApplicationHeaders["someByte"] == someByte);
            Assert.IsTrue((Boolean)messageBack.ApplicationHeaders["someBoolean"]);
            // c# has an conversion precision issue with decimal
            Assert.IsTrue((float)messageBack.ApplicationHeaders["soneFloat"] <= someFloat);
            float b = (float)messageBack.ApplicationHeaders["soneFloat"];

            Assert.IsTrue(Convert.ToInt32(b) == Convert.ToInt32(someFloat));
        }
 public static extern void SyncListener_director_connect(global::System.Runtime.InteropServices.HandleRef jarg1, SyncListener.SwigDelegateSyncListener_0 delegate0, SyncListener.SwigDelegateSyncListener_1 delegate1);
Exemplo n.º 9
0
 /*
  * Add SyncListener you want to sync with music beats using this method.
  * s : Listener
  * syncPointAmount : number of syncpoints that are jumped over (1 gives all, 4 every 2 seconds etc...).
  * firstOnBar : If the first trig needs to be on bar (on kick drum)
  */
 public static void AddMusicSyncListener(SyncListener s, int bpm)
 {
     SyncListenerNode syncListenerNode = new SyncListenerNode(s,bpm);
     syncListenerNodes.Add(syncListenerNode);
     //Debug.Log("List size: " + syncListenerNodes.Count);
 }
Exemplo n.º 10
0
 public static void StopCutScene()
 {
     if (initOK() == false)
        			return;
     StopAll();
     cutSceneListener = null;
 }
Exemplo n.º 11
0
 public static void StartCutScene(SyncListener c, String cutScene)
 {
     cutSceneListener = c;
     StartCutScene(cutScene);
 }
Exemplo n.º 12
0
 /*
  * OBS: bpm e {120,240,30}
  */
 public static void setMusicSyncBPM(SyncListener sl, int bpm)
 {
     //SyncListenerNode sln = null;
     //Debug.Log("FModSync.setSyncPointAmount(sl, " + bpm + ")");
     foreach (SyncListenerNode s in syncListenerNodes) {
         if (s.getSyncListener() == sl) {
             s.updateEveryNSyncPointUsed(bpm);
         }
     }
 }
Exemplo n.º 13
0
 public static void RemoveMusicSyncListener(SyncListener sl)
 {
     //Debug.Log("ATTEMPTING TO REMOVE " + syncListenerNodes.Count);
     SyncListenerNode toBeRemoved = null;
     foreach (SyncListenerNode s in syncListenerNodes) {
         if (s.getSyncListener() == sl) {
             toBeRemoved = s;
         }
     }
     if (toBeRemoved != null)
         syncListenerNodes.Remove(toBeRemoved);
     //Debug.Log("RESULT: " + syncListenerNodes.Count);
 }
        public void TestListeners()
        {
            IConfigurableCacheFactory ccf = CacheFactory.ConfigurableCacheFactory;

            IXmlDocument config = XmlHelper.LoadXml("assembly://Coherence.Tests/Tangosol.Resources/s4hc-local-cache-config.xml");

            ccf.Config = config;

            INamedCache cache = CacheFactory.GetCache("local-default");

            cache.Clear();

            SyncListener listen = new SyncListener();

            cache.AddCacheListener(listen, "test", false);
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("t", "a");
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("tes", "b");
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("test", "c");
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);

            listen.CacheEvent = null;
            Assert.IsNull(listen.CacheEvent);
            cache["test"] = "d";
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Updated);

            listen.CacheEvent = null;
            Assert.IsNull(listen.CacheEvent);
            cache.Remove("test");
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Deleted);

            cache.RemoveCacheListener(listen, "test");
            CacheEventFilter likeFilter = new CacheEventFilter(
                new LikeFilter(IdentityExtractor.Instance, "%ic", '\\', false));

            cache.AddCacheListener(listen, likeFilter, false);

            listen.CacheEvent = null;
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("key1", "Ratko");
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("key2", "PerIc");
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("key3", "RatkoviC");
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("key4", "Perovic");
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);

            cache.RemoveCacheListener(listen);

            cache.Clear();
            cache.AddCacheListener(listen);

            listen.CacheEvent = null;
            Assert.IsNull(listen.CacheEvent);

            cache.Insert("key1", "Ratko");
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);
            cache.Insert("key1", "Ratko NEW");
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Updated);

            cache.Insert("key2", "Pera");
            Assert.IsNotNull(listen.CacheEvent);
            Assert.AreEqual(listen.CacheEvent.EventType, CacheEventType.Inserted);

            cache.RemoveCacheListener(listen);

            CacheFactory.Shutdown();
        }
Exemplo n.º 15
0
        public virtual bool RegisterSyncListener(SyncListener listener)
        {
            bool ret = SharingClientPINVOKE.SharingManager_RegisterSyncListener(swigCPtr, SyncListener.getCPtr(listener));

            return(ret);
        }
Exemplo n.º 16
0
 public SyncListenerNode(SyncListener s, int e)
 {
     syncListener = s;
     everyNSyncPointUsed = e;
 }
        public void TestListeners()
        {
            INamedCache namedCache = CacheFactory.GetCache(CacheName);

            Hashtable ht = new Hashtable();

            ht.Add(GetKeyObject("Key1"), 435);
            ht.Add(GetKeyObject("Key2"), 253);
            ht.Add(GetKeyObject("Key3"), 3);
            ht.Add(GetKeyObject("Key4"), 200);
            ht.Add(GetKeyObject("Key5"), 333);
            namedCache.InsertAll(ht);

            IFilter greaterThan300          = new GreaterFilter(IdentityExtractor.Instance, 300);
            IFilter listenerFilter          = new CacheEventFilter(new GreaterFilter(IdentityExtractor.Instance, 350));
            ContinuousQueryCache queryCache = new ContinuousQueryCache(namedCache, greaterThan300);
            Listener             listener   = new SyncListener();

            // listener
            queryCache.AddCacheListener(listener);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 350);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Remove(GetKeyObject("Key5"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener);

            // listener, key, lite
            namedCache.Clear();
            namedCache.InsertAll(ht);
            queryCache.AddCacheListener(listener, GetKeyObject("Key5"), false);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key6"), 400);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key5"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Remove(GetKeyObject("Key1"));
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key5"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener, GetKeyObject("Key5"));

            // listener, filter, lite
            namedCache.Clear();
            namedCache.InsertAll(ht);
            queryCache.AddCacheListener(listener, listenerFilter, false);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key6"), 320);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key5"), 350);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Insert(GetKeyObject("Key6"), 400);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Updated, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            queryCache.Insert(GetKeyObject("Key7"), 340);
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key7"));
            Assert.IsNull(listener.CacheEvent);

            queryCache.Remove(GetKeyObject("Key6"));
            Assert.IsNotNull(listener.CacheEvent);
            Assert.AreEqual(CacheEventType.Deleted, listener.CacheEvent.EventType);

            queryCache.RemoveCacheListener(listener, listenerFilter);

            // non-sync listener, filter, heavy
            // COH-2529: Filter-based cache events are reevaluated on the client unncessarily
            listener       = new Listener();
            listenerFilter = new CacheEventFilter(new EqualsFilter("getZip", "02144"));
            namedCache.Clear();
            namedCache.AddCacheListener(listener, listenerFilter, false);

            listener.CacheEvent = null;
            namedCache[GetKeyObject("Jason")] = new Address("3 TBR #8", "Somerville", "MA", "02144");
            listener.waitForEvent(5000);
            Assert.IsNotNull(listener.CacheEvent);
            Assert.IsNotNull(listener.CacheEvent.NewValue);
            Assert.AreEqual(CacheEventType.Inserted, listener.CacheEvent.EventType);

            listener.CacheEvent = null;
            listener.waitForEvent(5000);
            namedCache[GetKeyObject("Oracle")] = new Address("8 NEEP", "Burlington", "MA", "01803");
            Assert.IsNull(listener.CacheEvent);

            namedCache.RemoveCacheListener(listener, listenerFilter);

            CacheFactory.Shutdown();
        }
 public virtual bool RegisterSyncListener(SyncListener listener) {
   bool ret = SharingClientPINVOKE.SharingManager_RegisterSyncListener(swigCPtr, SyncListener.getCPtr(listener));
   return ret;
 }