Hi. Thanks for the response..

->The ignite version used is 1.9.0.
->With Java Client its working fine.

--------------------------------- ignite config xml 
---------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans";
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd";>


        <import resource="file:connection-settings.xml" />
        
    <bean id="persistence_settings"
class="org.apache.ignite.cache.store.cassandra.persistence.KeyValuePersistenceSettings">
                <constructor-arg type="org.springframework.core.io.Resource"
value="file:persistence-settings-1.xml" />
        </bean>

    <bean id="ignite.cfg"
class="org.apache.ignite.configuration.IgniteConfiguration">
       
         <property name="clientMode" value="true"/> 
 
                 <property name="binaryConfiguration">
            <bean
class="org.apache.ignite.configuration.BinaryConfiguration">
                <property name="compactFooter" value="false"/>

                <property name="idMapper">
                    <bean
class="org.apache.ignite.binary.BinaryBasicIdMapper">
                        <property name="lowerCase" value="true"/>
                    </bean>
                </property>

                <property name="nameMapper">
                    <bean
class="org.apache.ignite.binary.BinaryBasicNameMapper">
                        <property name="simpleName" value="true"/>
                    </bean>
                </property>

                <property name="classNames">
                    <list>
                        <value>com.ignitetest.PersonPK</value>
                    </list>
                </property>
            </bean>
        </property>


                <property name="cacheConfiguration">
            <list>                
                <bean
class="org.apache.ignite.configuration.CacheConfiguration">
                    <property name="indexedTypes">
                        <list>
                            <value>com.ignitetest.PersonPK</value>
                            <value>com.ignitetest.Person</value>
                        </list>
                    </property>
                    <property name="name" value="cache1"/>
                    <property name="readThrough" value="true"/>
                    <property name="writeThrough" value="true"/>
                    <property name="cacheStoreFactory">
                        <bean
class="org.apache.ignite.cache.store.cassandra.CassandraCacheStoreFactory">
                            <property name="dataSourceBean"
value="cassandraAdminDataSource"/>
                            <property name="persistenceSettingsBean"
value="persistence_settings"/>
                        </bean>
                    </property>
                </bean>
           </list>
        </property>
  <property name="peerClassLoadingEnabled" value="true"></property>
        <property name="discoverySpi">
            <bean
class="org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi">
                <property name="ipFinder">                   
                    <bean
class="org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder">
                        <property name="addresses">
                            <list>
                                <value>127.0.0.1</value>
                            </list>
                        </property>
                    </bean>
                </property>
            </bean>
        </property>
    </bean>
</beans>

---------------------------------persistence settings 
---------------------------------------------------------
<persistence keyspace="testkeyspace" table="person">
        <keyPersistence class="com.ignitetest.PersonPK" strategy="POJO" />
    <valuePersistence class="com.ignitetest.Person" strategy="POJO" />
</persistence>

---------------------------------Person Pojo 
---------------------------------------------------------
package com.ignitetest;

public class Person {
        int col1;
        int col2;
        int col3;
        String col4;
        String col5;
        public int getCol1() {
                return col1;
        }
        public void setCol1(int col1) {
                this.col1 = col1;
        }
        public int getCol2() {
                return col2;
        }
        public void setCol2(int col2) {
                this.col2 = col2;
        }
        public int getCol3() {
                return col3;
        }
        public void setCol3(int col3) {
                this.col3 = col3;
        }
        public String getCol4() {
                return col4;
        }
        public void setCol4(String col4) {
                this.col4 = col4;
        }
        public String getCol5() {
                return col5;
        }
        public void setCol5(String col5) {
                this.col5 = col5;
        }
}
    
---------------------------------PersonPK Pojo 
---------------------------------------------------------
package com.ignitetest;

import org.apache.ignite.binary.BinaryObjectException;
import org.apache.ignite.binary.BinaryReader;
import org.apache.ignite.binary.BinaryWriter;
import org.apache.ignite.binary.Binarylizable;

public class PersonPK implements Binarylizable{
        int col1;
        String col5;
        public int getCol1() {
                return col1;
        }
        public void setCol1(int col1) {
                this.col1 = col1;
        }
        public String getCol5() {
                return col5;
        }
        public void setCol5(String col5) {
                this.col5 = col5;
        }
        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + col1;
                result = prime * result + ((col5 == null) ? 0 : 
col5.hashCode());
                return result;
        }
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                PersonPK other = (PersonPK) obj;
                if (col1 != other.col1)
                        return false;
                if (col5 == null) {
                        if (other.col5 != null)
                                return false;
                } else if (!col5.equals(other.col5))
                        return false;
                return true;
        }
        @Override
        public void readBinary(BinaryReader reader) throws 
BinaryObjectException {
                this.col1  = reader.readInt("col1");
                this.col5 = reader.readString("col5");
                
        }
        @Override
        public void writeBinary(BinaryWriter writer) throws 
BinaryObjectException {
                writer.writeInt("col1", col1);
                writer.writeString("col5", col5);       
        }
        
        
}

-----------------------------------------C++ pojo map header
---------------------------------------------

#ifndef _IGNITE_EXAMPLES_CPDU
#define _IGNITE_EXAMPLES_CPDU

#include <string>
#include <sstream>

#include "ignite/ignite.h"
#include "ignite/ignition.h"

namespace ignite
{
        struct Person
        {
           
            Person(int32_t _col1,int64_t _col2,int64_t _col3, const
std::string& _col4, const std::string& _col5):
                  col1(_col1),
                  col2(_col2),
                  col3(_col3),
                  col4(_col4),
                  col5(_col5)
            {
                // No-op.
            }
                        
            int32_t col1;
            int32_t col2;
            int32_t col3;
            std::string col4;
            std::string col5;
        };

                 struct PersonPK
          {
                          PersonPK(){

                          }     
 
              PersonPK(const ignite::PersonPK& copyfromPersonPK)
              {
                  col1         = copyfromPersonPK.col1;
                  col5         = copyfromPersonPK.col5;
              }
 
              PersonPK(int32_t _col1, const std::string& _col5):
                    col1(_col1),
                    col5(_col5)
              {
 
              }
 
              int32_t col1;
              std::string col5;
          };

}

namespace ignite
{
    namespace binary
    {
        IGNITE_BINARY_TYPE_START(ignite::Person)

            typedef ignite::Person Person;

            IGNITE_BINARY_GET_TYPE_ID_AS_HASH(Person)
            IGNITE_BINARY_GET_TYPE_NAME_AS_IS(Person)
            IGNITE_BINARY_GET_FIELD_ID_AS_HASH
            IGNITE_BINARY_GET_HASH_CODE_ZERO(Person)
            IGNITE_BINARY_IS_NULL_FALSE(Person)
            IGNITE_BINARY_GET_NULL_DEFAULT_CTOR(Person)

            void Write(BinaryWriter& writer, ignite::Person obj)
            {
                writer.WriteInt32("col1", obj.col1);
                writer.WriteInt32("col2", obj.col2);
                writer.WriteInt32("col3", obj.col3);
                writer.WriteString("col4", obj.col4);
                writer.WriteString("col5", obj.col5);
            }

            ignite::Person Read(BinaryReader& reader)
            {
                int32_t _col1 = reader.ReadInt32("col1");
                int32_t _col2 = reader.ReadInt32("col2");
                int32_t _col3 = reader.ReadInt32("col3");
                std::string _col4 = reader.ReadString("col4");
                std::string _col5 = reader.ReadString("col5");

                return ignite::Person(_col1, _col2, _col3, _col4, _col5);
            }

        IGNITE_BINARY_TYPE_END


          template<>
      struct BinaryType<PersonPK>
      {
        static int32_t GetTypeId()
        {
          return GetBinaryStringHashCode("PersonPK");
        }
 
        std::string GetTypeName()
        {
          return "PersonPK";
        }
 
        static int32_t GetFieldId(const char* name)
        {
          return GetBinaryStringHashCode(name);
        }
 
        static bool IsNull(const PersonPK& obj)
        {
          return false;
        }
 
        static void GetNull(PersonPK& dst)
        {
          dst = PersonPK();
        }
 
        static void Read(BinaryReader& reader, PersonPK& dst)
        {
          dst.col1 = reader.ReadInt32("col1");
          dst.col5 = reader.ReadString("col5");
        }
 
        static void Write(BinaryWriter& writer, const PersonPK& obj)
        {
          writer.WriteInt32("col1", obj.col1);
          writer.WriteString("col5", obj.col5);
       }
     };

    }
};


#endif // _IGNITE_EXAMPLES_CPDU

------------------------------------------------- ignite c++ client
---------------------------------------
#include <stdint.h>
#include <iostream>
#include "ignite/ignite.h"
#include "ignite/ignition.h"
#include "pojomap.h"

using namespace std;
using namespace ignite;
using namespace cache;
using namespace query;

void callIgnite();

int main()
{
        callIgnite();
        return 0;
}

void callIgnite()
{
        IgniteConfiguration cfg;
        cfg.springCfgPath = "default-config.xml";

        try
        {
                Ignite ignite = Ignition::Start(cfg);

                Person myPerson;
                PersonPK pk ;

                ResVector result;

                std::cout << std::endl;
                std::cout << ">>> Cassandra Cache query example started." << 
std::endl;
                std::cout << std::endl;

                Cache<PersonPK, Person> PersonCache = 
ignite.GetOrCreateCache<PersonPK,
Person>("cache1");

                std::cout << "CACHE SIZE before loadCache(): " <<
PersonCache.Size()<<std::endl; //initial 0
                PersonCache.LoadCache();
                std::cout << "CACHE SIZE after loadCache
:"<<PersonCache.Size()<<std::endl; // size after loading all = 4

                pk = PersonPK(1,"cust1");
                myPerson = PersonCache.Get(pk);
                std::cout<<myPerson.account_num<<endl;
                std::cout << "CACHE SIZE after Get 
1:"<<PersonCache.Size()<<std::endl; //
size 5
                
                PersonCache.Get(PersonPK(1,"cust1"));
                std::cout<<myPerson.account_num<<endl;
                std::cout << "CACHE SIZE after Get 
2:"<<PersonCache.Size()<<std::endl;  //
size 5
                
                Ignition::StopAll(false);
        }
        catch (IgniteError& err)
        {
                std::cout << "An error occurred: " << err.GetText() << 
std::endl;
        }
}







--
View this message in context: 
http://apache-ignite-users.70518.x6.nabble.com/c-ignite-cache-ContainsKey-key-object-method-returns-false-even-when-key-is-present-tp15862p15879.html
Sent from the Apache Ignite Users mailing list archive at Nabble.com.

Reply via email to